lapis_lazuli 0.6.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2a6cfbdb61af45b8f71d55cc4c1dbf39b4b93e8
+  data.tar.gz: 1bc6137ed31303b449740f200f34d10d750f9185
+SHA512:
+  metadata.gz: da0360f61b3574674db6af2e43c4fab53b6ab66ff58d01c2632ad1b063357f8db6f24bbfb5ce1d07eaa9f04fc7a5a65e154c65ceb69269880ecd48af6ee9dd38
+  data.tar.gz: 3b70d1935eed1f0a9bc00d237c3e3ec158aaeacf670b2a2a453ad43beeab60283b3511e289b4322572bd66781b5fd30e86553356ea1d97e5f71265c15a1fdfff

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+bundle
+pkg
+rdoc
+spec/reports
+tmp
+.ruby-version
+test/storage
+.*.sw*

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in spritecuke.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    lapis_lazuli (0.6.1)
+      facets (~> 2.9)
+      faraday (~> 0.9.0)
+      faraday_middleware (~> 0.9.1)
+      json (~> 1.8.1)
+      multi_xml (~> 0.5.5)
+      teelogger (~> 0.3.0)
+      thor (~> 0.19)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    docile (1.1.5)
+    facets (2.9.3)
+    faraday (0.9.1)
+      multipart-post (>= 1.2, < 3)
+    faraday_middleware (0.9.1)
+      faraday (>= 0.7.4, < 0.10)
+    json (1.8.2)
+    multi_json (1.11.0)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    rake (10.4.2)
+    simplecov (0.9.2)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.9.0)
+    simplecov-html (0.9.0)
+    teelogger (0.3.0)
+    thor (0.19.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  lapis_lazuli!
+  rake
+  simplecov

data/LICENSE

@@ -0,0 +1,30 @@
+Copyright spriteCloud B.V. (http://www.spritecloud.com/) and other LapisLazuli
+contributors. All rights not covered below are reserved.
+
+MIT +no-false-attribs License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+Distributions of all or part of the Software intended to be used by the
+recipients as they would use the unmodified Software, containing modifications
+that substantially alter, remove, or disable functionality of the Software,
+outside of the documented configuration mechanisms provided by the Software,
+shall be modified such that the Original Author's bug reporting email addresses
+and urls are either replaced with the contact information of the parties
+responsible for the changes, or removed entirely.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+# Lapis Lazuli
+
+LapisLazuli provides cucumber helper functions and scaffolding for easier (web)
+test automation suite development.
+
+A lot of functionality is aimed at dealing better with [Watir](http://watir.com/),
+such as:
+
+- Easier/more reliable find and wait functionality for detecting web page elements.
+- Easier browser handling
+- Better error handling
+- etc.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lapis_lazuli'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install lapis_lazuli
+```
+
+## Usage
+
+The Lapis Lazuli project has two main purposes:
+
+- Provide a repository of common test functions for test automation engineers.
+- Make it easy to get started on a test automation project with these test
+  functions.
+
+The first goal is fulfilled by the Lapis Lazuli module itself, which can be
+imported in any cucumber project like this:
+
+```ruby
+require 'lapis_lazuli'
+World(LapisLazuli)
+```
+
+All of Lapis Lazuli's helper functions will be available in your step definitions
+then. However, you won't need to do this if you create a new Lapis Lazuli project.
+Simple run:
+
+```bash
+$ lapis_lazuli create <projectpath>
+```
+
+And a cucumber project will be set up for you in the given path. The last path
+name component will be considered the project name, so e.g. a path of
+`projects/for_client/website1` will mean the project's name is going to be
+`website1`.
+
+Change to that newly created project directory and read the README.md file there
+for further instructions.
+
+Be sure to read [the Wiki](https://github.com/spriteCloud/lapis-lazuli/wiki) for
+further documentation.
+
+## Contributing
+
+Please see [the Wiki page on contributing](https://github.com/spriteCloud/lapis-lazuli/wiki/Contributing)
+
+## License
+Copyright (c) 2013-2015 spriteCloud B.V. and other node-apinator contributors. See [the LICENSE file](LICENSE) for details.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/lapis_lazuli

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'lapis_lazuli/cli'
+LapisLazuli::CLI.start

data/lapis_lazuli.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lapis_lazuli/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lapis_lazuli"
+  spec.version       = LapisLazuli::VERSION
+  spec.authors       = ["Onno Steenbergen", "Gijs Paulides", "Mark Barzilay", "Jens Finkhaeuser"]
+  spec.email         = ["foss@spritecloud.com"]
+  spec.description   = %q{Cucumber helper functions and scaffolding for easier test automation suite development.}
+  spec.summary       = %q{Cucumber helper functions and scaffolding for easier test automation suite development.}
+  spec.homepage      = "https://github.com/spriteCloud/lapis-lazuli"
+  spec.license       = "MITNFA"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "simplecov"
+
+  spec.add_dependency "thor", "~> 0.19"
+  spec.add_dependency "facets", "~> 2.9"
+  spec.add_dependency "json", "~> 1.8.1"
+  spec.add_dependency "faraday", "~> 0.9.0"
+  spec.add_dependency "faraday_middleware", "~> 0.9.1"
+  spec.add_dependency "multi_xml", "~> 0.5.5"
+  spec.add_dependency "teelogger", "~> 0.3.0"
+end

data/lib/lapis_lazuli/api.rb

@@ -0,0 +1,52 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+require "faraday"
+require "faraday_middleware"
+require "multi_xml"
+
+module LapisLazuli
+  ##
+  # Proxy class to map to sc-proxy
+  class API
+    attr_reader :conn
+    def initialize()
+    end
+
+    def set_conn(url, options=nil, &block)
+      block = block_given? ? block : Proc.new do |conn|
+        conn.response :xml,  :content_type => /\bxml$/
+        conn.response :json, :content_type => /\bjson$/
+
+        conn.adapter Faraday.default_adapter
+      end
+      @conn = Faraday.new(url, options, &block)
+    end
+
+    ##
+    # Map any missing method to the conn object or Faraday
+    def respond_to?(meth)
+      if !@conn.nil? and @conn.respond_to? meth
+        return true
+      end
+      return super
+    end
+
+    def method_missing(meth, *args, &block)
+      if !@conn.nil? and @conn.respond_to? meth
+        return @conn.send(meth.to_s, *args, &block)
+      end
+
+      begin
+        return Faraday.send(meth.to_s, *args, &block)
+      rescue NoMethodError
+        return super
+      end
+    end
+  end # class API
+end # module LapisLazuli

data/lib/lapis_lazuli/argparse.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 'test/unit/assertions'
+
+module LapisLazuli
+
+  ##
+  # Simple module that helps with function argument parsing.
+  module ArgParse
+    # Error related options.
+    ERROR_OPTIONS = {
+      :exception => nil,
+      :message => nil,
+      :groups => nil,
+    }
+
+    ##
+    # Parses its arguments, returning an options hash. Use it in a function that
+    # just accepts *args to handle both a single hash argument and a list of
+    # arguments:
+    #
+    # Example:
+    #   def foo(*args)
+    #     defaults = {}
+    #     options = parse_args(defaults, "bar", *args)
+    #   end
+    #
+    # The function essentially handles three distinct cases:
+    # 1. The arguments are a list:
+    #    foo(1, 2)
+    #      -> {"bar" => [1, 2]} merged with defaults
+    # 2. The first argument is a hash, and it contains "bar":
+    #    foo(:x => 1, "bar" => [1, 2])
+    #      -> {:x => 1, "bar" => [1, 2]} merged with defaults
+    # 3. The first argument is a hash and it does not contain "bar"
+    #    foo(:x => 1)
+    #      -> {"bar" => [{:x => 1}]} merged with defaults
+    #
+    # Either option ensures that the second parameter "bar" exists and is an
+    # array. Also, all defaults are merged into the options hash.
+    def parse_args(defaults, list, *args)
+      options = {}
+
+      # If we have a single hash argument, we'll treat it as defaults, and expect
+      # the list field to be an Array
+      if 1 == args.length and args[0].is_a? Hash
+        tmp = args[0]
+
+        if tmp.has_key? list
+          # Assert that the list argument is a list. Duh.
+          assert tmp[list].is_a?(Array), "Need to provide an Array for #{list}."
+
+          # Merge defaults
+          tmp = defaults.merge tmp
+
+          options = tmp
+        else
+          # No list means that we only have a single argument, which
+          # is meant to be the single list item. Any option with defaults
+          # must be taken from tmp, if it exists there.
+          options = defaults
+          tmp.each do |k, v|
+            if options.has_key? k
+              options[k] = tmp[k]
+              tmp.delete(k)
+            end
+          end
+          options[list] = [tmp]
+        end
+
+      else
+        options = defaults
+        options[list] = args
+      end
+
+      # Finally, prune options: remove all nil values
+      options.each do |k, v|
+        if v.nil?
+          options.delete k
+        end
+      end
+
+      return options
+    end
+
+
+    ##
+    # Simple way for dealing with an argument that can be either a list, or a
+    # single item: we distinguish based on whether the argument responds to 'each'.
+    # If the optional 'flatten' parameter is given, nested lists will also be
+    # flattened.
+    def make_list_from_item(item, flatten = false)
+      res = []
+      if item.respond_to?('each')
+        item.each do |e|
+          if flatten
+            res << make_list_from_item(e)
+          else
+            res << e
+          end
+        end
+      else
+        res << item
+      end
+      return res
+    end
+
+
+    ##
+    # Using make_list_from_item, apply the logic to all of an array. It
+    # effectively flattens nested arrays, if necessary, and does so
+    # recursively if the flatten parameter is true.
+    def make_list_from_nested(list, flatten = false)
+      all = []
+      list.each do |item|
+        all.concat(make_list_from_item(item, flatten))
+      end
+      return all
+    end
+
+  end # module ArgParse
+end # module LapisLazuli

data/lib/lapis_lazuli/ast.rb

@@ -0,0 +1,160 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2015 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+# Hack for cucumber 2.0.x
+begin
+  module Cucumber
+    module Core
+      module Ast
+        class ExamplesTable
+          public :example_rows
+        end # ExamplesTable
+      end # Ast
+    end # Core
+  end # Cucumber
+rescue NameError
+  # Not cucumber 2.0.x
+end
+
+
+module LapisLazuli
+  ##
+  # Convenience module for dealing with aspects of the cucumber AST. From
+  # version 1.3.x to version 2.0.x, some changes were introduced here.
+  module Ast
+    ##
+    # Return a unique and human parsable ID for scenarios
+    def scenario_id(scenario)
+      # For 2.0.x, the best scenario ID is one prefixed by the file name + line
+      # number, followed by the feature name, scenario name, and table data (if
+      # applicable).
+      if is_cucumber_2?(scenario)
+        id = [scenario.location.to_s]
+        for i in 0 .. scenario.source.length - 1 do
+          part = scenario.source[i]
+          if part.respond_to?(:name)
+            id << part.name
+          elsif part.is_a?(Cucumber::Core::Ast::ExamplesTable::Row)
+            id << part.values.join("|")
+          end
+        end
+        return id
+      end
+
+      case scenario
+      when Cucumber::Ast::Scenario
+        return [
+          scenario.feature.file,
+          scenario.name
+        ]
+      when Cucumber::Ast::OutlineTable::ExampleRow
+        return [
+          scenario.scenario_outline.feature.file,
+          scenario.scenario_outline.name,
+          scenario.name
+        ]
+      end
+    end
+
+
+    ##
+    # Tests whether the given scenario object indicates we're using cucumber 2.x
+    def is_cucumber_2?(scenario)
+      begin
+        # The assumption - FIXME perhaps wrong - is that cucumber 1.3.x does not
+        # have this source array.
+        return (scenario.respond_to?(:source) and scenario.source.is_a?(Array))
+      rescue
+        return false
+      end
+    end
+
+
+    ##
+    # Tests whether the scenario object is a single scenario
+    def is_scenario?(scenario)
+      begin
+        # 1.3.x
+        return scenario.class == Cucumber::Ast::Scenario
+      rescue
+        # 2.0.x - everything is a Cucumber::Core::Test::Case
+        return (not scenario.outline?)
+      end
+    end
+
+
+    ##
+    # Tests whether the scenario object is a table row
+    def is_table_row?(scenario)
+      begin
+        # 1.3.x
+        return scenario.class == Cucumber::Ast::OutlineTable::ExampleRow
+      rescue
+        # 2.0.x - everything is a Cucumber::Core::Test::Case
+        return scenario.outline?
+      end
+    end
+
+
+    ##
+    # Tests whether this scenario is the last scenario of a feature
+    def is_last_scenario?(scenario)
+      if is_scenario?(scenario)
+        begin
+          # 2.0.x
+          return (scenario.feature.feature_elements.last.location == scenario.location)
+        rescue
+          # 1.3.x
+          return (scenario.feature.feature_elements.last == scenario)
+        end
+
+      elsif is_table_row?(scenario)
+        begin
+          # 2.0.x
+
+          # We can bail early if this scenario's line is < the last feature
+          # element's line
+          outline = scenario.feature.feature_elements.last
+          if scenario.source.last.location.line < outline.location.line
+            return false
+          end
+
+          # Now the last feature element needs to be an outline - this is a
+          # sanity check that makes later stuff easier
+          if not outline.respond_to? :examples_tables
+            return false
+          end
+
+          # The last row of the last examples tables is what we care about
+          last_row = outline.examples_tables.last.example_rows.last
+
+          # If the current scenario has the same location as the last example,
+          # then we're the last scenario.
+          return scenario.source.last.location.line == last_row.location.line
+
+        rescue
+          # 1.3.x
+          if scenario.scenario_outline.feature.feature_elements.last == scenario.scenario_outline
+            # And is this the last example in the table?
+            is_last_example = false
+            scenario.scenario_outline.each_example_row do |row|
+              if row == scenario
+                is_last_example = true
+              else
+                # Overwrite this again with 'false'
+                is_last_example = false
+              end
+            end
+            return is_last_example
+          end
+        end
+      end
+      raise "If you see this error it might indicate you're running an unsupported version of cucumber"
+    end
+  end # module Ast
+end # module LapisLazuli

data/lib/lapis_lazuli/browser/error.rb

@@ -0,0 +1,93 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+module LapisLazuli
+module BrowserModule
+
+  ##
+  # Module with error handling related functionality (World)
+  module Error
+    ##
+    # Does this page have errors?
+    # Checks the pagetext for error_strings that are specified in the config
+    def has_error?
+      errors = self.get_html_errors
+      js_errors = self.get_js_errors
+      if not js_errors.nil?
+        errors += js_errors
+      end
+
+      if errors.length > 0 or self.get_http_status.to_i > 299
+        errors.each do |error|
+          if error.is_a? Hash
+            @world.log.debug("#{error["message"]} #{error["url"]} #{error["line"]} #{error["column"]}\n#{error["stack"]}")
+          else
+            @world.log.debug("#{error}")
+          end
+        end
+        return true
+      end
+      return false
+    end
+
+
+    ##
+    # Retrieve errors from HTML elements, using the error_strings config
+    # variable
+    def get_html_errors
+      result = []
+      # Need some error strings
+      if @world.has_env_or_config?("error_strings")
+        begin
+          # Get the HTML of the page
+          page_text = @browser.html
+          # Try to find all errors
+          @world.env_or_config("error_strings").each {|error|
+            if page_text.include? error
+              # Add to the result list
+              result.push error
+            end
+          }
+        rescue RuntimeError => err
+          # An error?
+          @world.log.debug "Cannot read the html for page #{@browser.url}: #{err}"
+        end
+      end
+      # By default we don't have errors
+      return result
+    end
+
+
+    ##
+    # If the proxy is supported, use it to retrieve JS errors.
+    def get_js_errors
+      return self.browser.execute_script <<-JS
+        try {
+          return lapis_lazuli.errors;
+        } catch(err){
+          return null;
+        }
+      JS
+    end
+
+
+    ##
+    # If the proxy is supported, use it get the HTTP status code.
+    def get_http_status
+      return self.browser.execute_script <<-JS
+        try{
+          return lapis_lazuli.http.statusCode;
+        } catch(err){
+          return null;
+        }
+      JS
+    end
+
+  end # module Error
+end # module BrowserModule
+end # module LapisLazuli