lapis_lazuli 0.6.1

data/lib/lapis_lazuli/storage.rb

@@ -0,0 +1,59 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+module LapisLazuli
+  ##
+  # Simple storage class
+  class Storage
+    @data
+    def initialize
+      @data = {}
+    end
+
+    def set(key, value)
+      @data[key] = value
+    end
+
+    def get(key)
+      return @data[key]
+    end
+
+    def has?(key)
+      return @data.include? key
+    end
+
+    ##
+    # Write all stored data to file
+    def writeToFile(filename)
+      # Make storage directory
+      dir = File.dirname(filename)
+      begin
+        Dir.mkdir dir
+      rescue SystemCallError => ex
+        # Swallow this error; it occurs (amongst other situations) when the
+        # directory exists. Checking for an existing directory beforehand is
+        # not concurrency safe.
+      end
+
+      File.open(filename, 'w') { |file|
+        # Write the JSON to the file
+        file.write(@data.to_json)
+      }
+    end
+
+    ##
+    # This will be called during the destruction of the world
+    def destroy(world)
+      filename = world.config("storage_dir", ".#{File::SEPARATOR}storage") +
+        File::SEPARATOR +
+        world.time[:timestamp] +
+        ".json"
+      world.log.debug("Writing storage to: #{filename}")
+      self.writeToFile(filename)
+    end
+  end
+end

data/lib/lapis_lazuli/version.rb

@@ -0,0 +1,10 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2015 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+module LapisLazuli
+  VERSION = "0.6.1"
+end

data/lib/lapis_lazuli/versions.rb

@@ -0,0 +1,40 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+require 'lapis_lazuli/api'
+
+module LapisLazuli
+
+  ##
+  # Given a versions string or hash, stores it for later use with the library.
+  attr_accessor :software_versions
+  extend self
+
+  ##
+  # Connedt to the endpoint or to ENV['VERSION_ENDPOINT'], then retrieve the
+  # url. The contents should be the software versions used.
+  def self.fetch_versions(url, endpoint = nil)
+    # Set the connection endpoint. This is either the endpoint, or the
+    # environment variable 'VERSION_ENDPOINT'.
+    if ENV.has_key?('VERSION_ENDPOINT')
+      endpoint = ENV['VERSION_ENDPOINT']
+    end
+
+    # Connect to the endpoint
+    api = API.new
+    api.set_conn(endpoint)
+
+    # Fetch versions
+    response = api.get(url)
+    if 2 != response.status / 100
+      raise "Error retrieving software versions, got status code #{response.status}"
+    end
+
+    # Store that stuff for later.
+    self.software_versions = response.body
+  end
+end # module LapisLazuli

data/lib/lapis_lazuli/world/annotate.rb

@@ -0,0 +1,45 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+require 'json'
+
+require 'lapis_lazuli/argparse'
+
+module LapisLazuli
+module WorldModule
+  ##
+  # Module with annotation related functionality
+  #
+  # Annotations are embedded into the report via cucumber's embed function, and
+  # that means they're embedded at the step level.
+  #
+  # They're also stored at scenario scope, so one step in a scenario can access
+  # annotations made in another step.
+  module Annotate
+
+    include LapisLazuli::ArgParse
+
+    def annotate(*args)
+      @annotations ||= {}
+
+      scope = scenario.scope(true) || 'items'
+      stuff = parse_args({}, scope, *args)
+
+      for_scope = @annotations.fetch(scope, [])
+      for_scope << stuff[scope]
+      @annotations[scope] = for_scope
+
+      embed(JSON.generate(stuff), 'application/json')
+    end
+
+    def annotations
+      @annotations
+    end
+  end # module Annotate
+end # module WorldModule
+end # module LapisLazuli

data/lib/lapis_lazuli/world/api.rb

@@ -0,0 +1,35 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+require "lapis_lazuli/api"
+require "lapis_lazuli/runtime"
+
+module LapisLazuli
+module WorldModule
+  ##
+  # Module managing an API instance
+  module API
+
+    ##
+    # Has API?
+    def has_api?
+      a = Runtime::instance.get :api
+      return !a.nil?
+    end
+
+    ##
+    # Get/create the API instance
+    def api
+      return Runtime.instance.set_if(self, :api) do
+        LapisLazuli::API.new
+      end
+    end
+
+  end # module API
+end # module WorldModule
+end # module LapisLazuli

data/lib/lapis_lazuli/world/browser.rb

@@ -0,0 +1,75 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+require "lapis_lazuli/browser"
+require "lapis_lazuli/runtime"
+
+require "lapis_lazuli/world/config"
+require "lapis_lazuli/world/logging"
+require "lapis_lazuli/world/error"
+require "lapis_lazuli/world/proxy"
+
+module LapisLazuli
+module WorldModule
+  ##
+  # Module managing a browser instance
+  module Browser
+    include LapisLazuli::WorldModule::Config
+    include LapisLazuli::WorldModule::Logging
+    include LapisLazuli::WorldModule::Error
+    include LapisLazuli::WorldModule::Proxy
+
+    ##
+    # Store extension modules for the browser
+    module ClassMethods
+      def browser_module(module_name)
+        @extensions ||= []
+        @extensions << module_name
+      end
+
+      def browser_modules
+        @extensions
+      end
+    end
+    extend ClassMethods
+
+    ##
+    # Checks if there is a browser started
+    def has_browser?
+      b = Runtime.instance.get :browser
+      return (not b.nil? and b.is_open?)
+    end
+
+    ##
+    # Get the current main browser
+    def browser(*args)
+      b = Runtime.instance.set_if(self, :browser) do
+        # Add LL to the arguments for the browser
+        browser_args = args.unshift(self)
+        # Create a new browser object
+        inst = LapisLazuli::Browser.new(*browser_args)
+        # Extend the instance
+        if not Browser.browser_modules.nil?
+          Browser.browser_modules.each do |ext|
+            inst.extend(ext)
+          end
+        end
+        # Return the instance
+        inst
+      end
+
+      if not b.is_open?
+        b.start
+      end
+
+      return b
+    end
+
+  end # module Browser
+end # module WorldModule
+end # module LapisLazuli

data/lib/lapis_lazuli/world/config.rb

@@ -0,0 +1,292 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+require "lapis_lazuli/options"
+
+module LapisLazuli
+module WorldModule
+  ##
+  # Module with configuration loading related functions
+  #
+  # Manages the following:
+  #   @config          - internal configuration representation
+  #   config_file      - Needs to be set before config can be accessed.
+  #   @env             - loaded/detected config/test environment
+  module Config
+    ##
+    # Explicitly store the configuration file name.
+    module ClassMethods
+      def config_file=(name)
+        @config_file = name
+      end
+
+      def config_file
+        return @config_file || "config/config.yml"
+      end
+    end
+    extend ClassMethods
+
+
+    ##
+    # The configuration is not a singleton, precisely, but it does not need to
+    # be created more than once. Note that explicitly calling load_config will
+    # still work to overwrite an existing configuration.
+    def init
+      # Guard against doing this more than once.
+      if not @config.nil?
+        return
+      end
+
+      if Config.config_file.nil?
+        raise "No configuration file provided, set LapisLazuli::WorldModule::Config.config_file"
+      end
+
+      load_config(Config.config_file)
+
+      if @config.nil?
+        raise "Could not load configuration."
+      end
+    end
+
+
+    ##
+    # Loads a config based on a filename
+    #
+    # Supports: YML, JSON
+    #
+    # Example:
+    #   ENV['TEST_ENV'] = 'production'
+    #   load_config("config/config.yml")
+    #
+    # Will try to load the following files:
+    # - config/config-production.yml
+    # - config/config-debug.yml
+    # - config/config-test.yml
+    # - config/config-local.yml
+    # - config/config.yml
+    def load_config(config_name)
+      # Split the filename
+      ext = File.extname(config_name)
+      dir, filename = File.split(config_name)
+      basename = File.basename(filename, ext)
+
+      # What are the suffixes to check
+      suffixes = [
+        "debug",
+        "test",
+        "local"
+      ]
+
+      if ENV["TEST_ENV"]
+        @env = ENV["TEST_ENV"]
+      end
+
+      # Do we have an environment
+      if not @env.nil?
+        # Add it to the suffixes
+        suffixes.unshift(@env)
+      end
+
+      # Turn suffixes into files to try
+      files = []
+      suffixes.each do |suffix|
+        files << "#{dir}#{File::SEPARATOR}#{basename}-#{suffix}#{ext}"
+      end
+      files << config_name
+
+      # Try all files in order
+      files.each do |file|
+        begin
+          # Try to load a config file
+          return self.load_config_from_file(file)
+        rescue
+          # Do nothing, load the next file
+        end
+      end
+    end
+
+
+    ##
+    # Loads a config file
+    #
+    # Supports: YML, JSON
+    #
+    # Throws errors if:
+    # - Config file isn't readable
+    # - Environment doesn't exist in config
+    # - Default environment not set in config if no environment is set
+    def load_config_from_file(filename)
+      # Try to load the file from disk
+      begin
+        # Determine the extension
+        ext = File.extname(filename)
+        # Use the correct loader
+        if ext == ".yml"
+          @config = YAML.load_file(filename)
+        elsif ext == ".json"
+          json = File.read(filename)
+          @config = JSON.parse(json)
+        end
+      rescue RuntimeError => err
+        # Can't help you
+        raise "Error loading file: #{filename} #{err}"
+      end
+
+      # If we have an environment this config should have it
+      if not @env.nil? and not self.has_config?(@env)
+        raise "Environment doesn't exist in config file"
+      end
+
+      # If we don't have one then load the default
+      if @env.nil? and self.has_config?("default_env")
+        tmp = self.config("default_env")
+        if self.has_config?(tmp)
+          @env = tmp
+        else
+          raise "Default environment not present in config file"
+        end
+      end
+    end
+
+
+
+    ##
+    # Does the config have a variable?
+    # Uses config and catches any errors it raises
+    def has_config?(variable)
+      # Make sure the configured configuration is loaded, if possible
+      init
+
+        begin
+          value = self.config(variable)
+          return (not value.nil?)
+        rescue RuntimeError => err
+          return false
+        end
+    end
+
+    ##
+    # Get the configuration from the config,
+    # uses a dot seperator for object traversing
+    #
+    # Example:
+    # ll.config("test.google.url") => "www.google.com"
+    #
+    # Raises error if traversing the object is impossible
+    def config(variable=false, default=nil)
+      # Make sure the configured configuration is loaded, if possible
+      init
+
+      # No variable given? Return the entire object.
+      result = @config
+      if not variable
+        return result
+      end
+
+      # Environment variables for known options override the option.
+      if CONFIG_OPTIONS.has_key? variable
+        var = variable.upcase
+        if ENV.has_key? var
+          return ENV[var]
+        end
+      end
+
+      # Otherwise try to find it in the configuration object
+      variable.split(".").each do |part|
+        if default.nil? and result.nil?
+          raise "Unknown configuration variable '#{variable}' and no default given!"
+        end
+        break if result.nil?
+        result = result[part]
+      end
+
+      if default.nil? and result.nil?
+        if CONFIG_OPTIONS.has_key? variable
+          return CONFIG_OPTIONS[variable][0]
+        else
+          raise "Unknown configuration variable '#{variable}' and no default given!"
+        end
+      else
+        return result || default
+      end
+    end
+
+    ##
+    # Does the environment have a certain config variable
+    def has_env?(variable)
+      # Make sure the configured configuration is loaded, if possible
+      init
+
+      if @env.nil?
+        return false
+      end
+      return self.has_config?("#{@env}.#{variable}")
+    end
+
+    ##
+    # Returns current environment
+    def current_env
+      init
+      
+      return @env
+    end
+
+    ##
+    # Get a environment variable from the config file
+    # Alias for ll.config(ll.env + "." + variable)
+    def env(variable=false, default=nil)
+      # Make sure the configured configuration is loaded, if possible
+      init
+
+      if not variable
+        return self.config(@env)
+      end
+
+      # Environment variables for known options override environment specific
+      # options, too
+      if CONFIG_OPTIONS.has_key? variable
+        var = variable.upcase
+        if ENV.has_key? var
+          return ENV[var]
+        end
+      end
+
+      return self.config("#{@env}.#{variable}",default)
+    end
+
+    ##
+    # Checks if a variabl exist in the env or config
+    def has_env_or_config?(variable)
+      # Make sure the configured configuration is loaded, if possible
+      init
+
+      return self.has_env?(variable) || self.has_config?(variable)
+    end
+
+    ##
+    # Get a variable from the config
+    # First checks the environment section, before it checks the global part
+    def env_or_config(variable, default=nil)
+      # Make sure the configured configuration is loaded, if possible
+      init
+
+      if self.has_env?(variable)
+        return self.env(variable, default)
+      elsif self.has_config?(variable)
+        return self.config(variable, default)
+      else
+        return nil
+      end
+    end
+
+
+
+
+  end # module Config
+end # module WorldModule
+end # module LapisLazuli

data/lib/lapis_lazuli/world/error.rb

@@ -0,0 +1,141 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+module LapisLazuli
+module WorldModule
+  ##
+  # Module with error handling related functionality
+  module Error
+    ##
+    # Throw an error based on some settings
+    #
+    # Examples:
+    # ll.error("Simple message") => "Simple message"
+    # ll.error(:message => "Simple message") => "Simple message"
+    # ll.error(:env => "test") => "Environment setting 'test' not found"
+    # ll.error(:env => "test", :exists => true) => "Environment setting 'test' found"
+    # ll.error(:screenshot => true, :message => "Simple") => "Simple", and screenshot is taken with the message name included.
+    def error(settings=nil)
+      # Default message
+      message = nil
+      groups = nil
+
+      # Default actions
+      screenshot = false
+      exception = nil
+
+      # Do we have settings
+      if not settings.nil?
+        # Simple string input
+        if settings.is_a? String
+          message = settings
+        elsif settings.is_a? Hash
+          if settings.has_key? :message
+            message = settings[:message]
+          end
+          # Environment errors
+          if settings.has_key? :env
+            # Does the value exist or not?
+            exists = ""
+            if not (settings.has_key?(:exists) or settings[:exists])
+              exists = ' not'
+            end
+            message = "Environment setting '#{settings[:env]}'" +
+                      exists + " found"
+          end
+
+          if settings.has_key? :scenario
+            message = "Scenario failed: #{settings[:scenario]}"
+          elsif settings.has_key? :not_found
+            message = "Not found: #{settings[:not_found]}"
+          end
+
+          # Grouping of errors
+          if settings.has_key? :groups
+            grouping = settings[:groups]
+            if grouping.is_a? String
+              groups = [grouping]
+            elsif grouping.is_a? Array
+              groups = grouping
+            end
+          end
+
+          # Exception message shouldn't get lost
+          if settings.has_key? :exception and not settings[:exception].nil?
+            exception = settings[:exception]
+            if message.nil?
+              message = settings[:exception].message
+            else
+              message = "#{message} - #{settings[:exception].message}"
+            end
+          elsif message.nil?
+            message = "An unknown error occurred."
+          end
+
+          # Check if we want to take a screenshot
+          if settings.has_key? :screenshot
+            screenshot = !!settings[:screenshot]
+          end
+        end
+      end
+
+      # Include URL if we have a browser
+      if self.has_browser?
+        message += " (#{self.browser.url})"
+      end
+
+      # Add the groups to the message
+      if not groups.nil?
+        message = "[#{groups.join("][")}] #{message}"
+      end
+
+      # Write the error to the log
+      if self.log
+        self.log.error(message)
+      end
+
+      # Take screenshot, if necessary
+      if screenshot
+        self.browser.take_screenshot(message)
+      end
+
+      # Start debugger, if necessary
+      if self.env_or_config("breakpoint_on_error")
+        self.start_debugger
+      end
+
+      # Raise the message
+      if not exception.nil?
+        # message already contains ex.message here - or it should
+        raise exception.class, message, exception.backtrace
+      else
+        raise message
+      end
+    end
+
+    ##
+    # If byebug (ruby >= 2.0) or debugger (ruby < 2.0) are installed, start
+    # the debugger now.
+    def start_debugger
+      # First try the more modern 'byebug'
+      begin
+        require "byebug"
+        byebug
+      rescue LoadError
+        # If that fails, try the older debugger
+        begin
+          require 'debugger'
+          debugger
+        rescue LoadError
+          self.log.info "No debugger found, can't break on failures."
+        end
+      end
+    end
+  end # module Error
+end # module WorldModule
+end # module LapisLazuli