class Bauxite::Context

The Main test context. This class includes state and helper functions used by clients execute tests and by actions and selectors to interact with the test engine (i.e. Selenium WebDriver).

Attributes

driver[R]

Test engine driver instance (Selenium WebDriver).

logger[R]

Logger instance.

options[R]

Test options.

tests[RW]

Test containers.

variables[RW]

Context variables.

Public Class Methods

new(options) click to toggle source

Constructs a new test context instance.

options is a hash with the following values:

:driver: selenium driver symbol (defaults to :firefox)
:timeout: selector timeout in seconds (defaults to 10s)
:logger: logger implementation name without the 'Logger' suffix (defaults to 'null' for Loggers::NullLogger).
:verbose: if true, show verbose error information (e.g. backtraces) if an error occurs (defaults to false)
:debug: if true, break into the debug console if an error occurs (defaults to false)
:wait: if true, call ::wait before stopping the test engine with stop (defaults to false)
:extensions: an array of directories that contain extensions to be loaded

# File lib/bauxite/core/context.rb, line 69
def initialize(options)
        @options = options
        @driver_name = (options[:driver] || :firefox).to_sym
        @variables = {
                '__TIMEOUT__' => (options[:timeout] || 10).to_i,
                '__DEBUG__'   => false
        }
        @aliases = {}
        @tests = []
        
        _load_extensions(options[:extensions] || [])
        
        handle_errors do
                @logger = Context::load_logger(options[:logger], options[:logger_opt])
        end
        
        @parser = Parser.new(self)
end

Public Instance Methods

debug() click to toggle source

Breaks into the debug console.

For example:

ctx.debug
# => this breaks into the debug console

# File lib/bauxite/core/context.rb, line 176
def debug
        exec_action('debug', false)
end

find(selector) { |element| ... } click to toggle source

Finds an element by selector.

The element found is yielded to the given block (if any) and returned.

Note that the recommeneded way to call this method is by passing a block. This is because the method ensures that the element context is maintained for the duration of the block but it makes no guarantees after the block completes (the same applies if no block was given).

For example:

ctx.find('css=.my_button') { |element| element.click }
ctx.find('css=.my_button').click

For example (where using a block is mandatory):

ctx.find('frame=|myframe|css=.my_button') { |element| element.click }
# => .my_button clicked

ctx.find('frame=|myframe|css=.my_button').click
# => error, cannot click .my_button (no longer in myframe scope)

# File lib/bauxite/core/context.rb, line 165
def find(selector, &block) # yields: element
        with_timeout Selenium::WebDriver::Error::NoSuchElementError do
                Selector.new(self).find(selector, &block)
        end
end

get_value(element) click to toggle source

Returns the value of the specified element.

This method takes into account the type of element and selectively returns the inner text or the value of the value attribute.

For example:

# assuming <input type='text' value='Hello' />
#          <span id='label'>World!</span>

ctx.get_value(ctx.find('css=input[type=text]'))
# => returns 'Hello'

ctx.get_value(ctx.find('label'))
# => returns 'World!'

# File lib/bauxite/core/context.rb, line 195
def get_value(element)
        if ['input','select','textarea'].include? element.tag_name.downcase
                element.attribute('value') 
        else
                element.text
        end
end

reset_driver() click to toggle source

Stops the test engine and starts a new engine with the same provider.

For example:

ctx.reset_driver
=> closes the browser and opens a new one

# File lib/bauxite/core/context.rb, line 120
def reset_driver
        @driver.quit
        _load_driver
end

start(actions = []) click to toggle source

Starts the test engine and executes the actions specified. If no action was specified, returns without stopping the test engine (see stop).

For example:

lines = [
    'open "http://www.ruby-lang.org"',
    'write "name=q" "ljust"',
    'click "name=sa"',
    'break'
]
ctx.start(lines.map { |l| ctx.parse_action(l) })
# => navigates to www.ruby-lang.org, types ljust in the search box
#    and clicks the "Search" button.

# File lib/bauxite/core/context.rb, line 102
def start(actions = [])
        _load_driver
        return unless actions.size > 0
        begin
                actions.each do |action|
                        exec_action(action)
                end
        ensure
                stop
        end
end

stop() click to toggle source

Stops the test engine.

Calling this method at the end of the test is mandatory if start was called without actions.

Note that the recommeneded way of executing tests is by passing a list of actions to start instead of using the start / stop pattern.

For example:

ctx.start(:firefox) # => opens firefox

# test stuff goes here

ctx.stop            # => closes firefox

# File lib/bauxite/core/context.rb, line 140
def stop
        Context::wait if @options[:wait]
        @driver.quit
end

Advanced Helpers

↑ top

Public Class Methods

load_logger(name, options) click to toggle source

Constructs a Logger instance using name as a hint for the logger type.

# File lib/bauxite/core/context.rb, line 316
def self.load_logger(name, options)
        log_name = (name || 'null').downcase
        
        class_name = "#{log_name.capitalize}Logger"
        
        unless Loggers.const_defined? class_name.to_sym
                raise NameError,
                        "Invalid logger '#{log_name}'"
        end
        
        Loggers.const_get(class_name).new(options)
end

parse_action_default(text, file = '', line = 0) click to toggle source

Default action parsing strategy.

# File lib/bauxite/core/context.rb, line 338
def self.parse_action_default(text, file = '<unknown>', line = 0)
        data = text.split(' ', 2)
        begin
                args_text = data[1] ? data[1].strip : ''
                args = []
                
                unless args_text == ''
                        # col_sep must be a regex because String.split has a
                        # special case for a single space char (' ') that produced
                        # unexpected results (i.e. if line is '"a      b"' the
                        # resulting array contains ["a b"]).
                        #
                        # ...but... 
                        #
                        # CSV expects col_sep to be a string so we need to work
                        # some dark magic here. Basically we proxy the StringIO
                        # received by CSV to returns strings for which the split
                        # method does not fold the whitespaces.
                        #
                        args = CSV.new(StringIOProxy.new(args_text), { :col_sep => ' ' })
                        .shift
                        .select { |a| a != nil } || []
                end
                
                {
                        :action => data[0].strip.downcase,
                        :args   => args
                }
        rescue StandardError => e
                raise "#{file} (line #{line+1}): #{e.message}"
        end
end

wait() click to toggle source

Prompts the user to press ENTER before resuming execution.

For example:

Context::wait
# => echoes "Press ENTER to continue" and waits for user input

# File lib/bauxite/core/context.rb, line 309
def self.wait
        Readline.readline("Press ENTER to continue\n")
end

Public Instance Methods

add_alias(name, action, args) click to toggle source

Adds an alias named name to the specified action with the arguments specified in args.

# File lib/bauxite/core/context.rb, line 332
def add_alias(name, action, args)
        @aliases[name] = { :action => action, :args => args }
end

exec_action(text, log = true, file = '', line = 0) click to toggle source

Executes the specified action string handling errors, logging and debug history.

If log is true, log the action execution (default behavior).

For example:

ctx.exec_action 'open "http://www.ruby-lang.org"'
# => navigates to www.ruby-lang.org

# File lib/bauxite/core/context.rb, line 216
def exec_action(text, log = true, file = '<unknown>', line = 0)
        data = Context::parse_action_default(text, file, line)
        _exec_parsed_action(data[:action], data[:args], text, log, file, line)
end

exec_file(file) click to toggle source

Executes the specified file.

For example:

ctx.exec_file('file')
# => executes every action defined in 'file'

# File lib/bauxite/core/context.rb, line 227
def exec_file(file)
        @parser.parse(file) do |action, args, text, file, line|
                _exec_parsed_action(action, args, text, true, file, line)
        end
end

handle_errors(break_into_debug = false, exit_on_error = true) { || ... } click to toggle source

Executes the block inside a rescue block applying standard criteria of error handling.

The default behavior is to print the exception message and exit.

If the :verbose option is set, the exception backtrace will also be printed.

If the break_into_debug argument is true and the :debug option is set, the handler will break into the debug console instead of exiting.

If the exit_on_error argument is false the handler will not exit after printing the error message.

For example:

ctx = Context.new({ :debug => true })
ctx.handle_errors(true) { raise 'break into debug now!' }
# => this breaks into the debug console

# File lib/bauxite/core/context.rb, line 252
def handle_errors(break_into_debug = false, exit_on_error = true)
        yield
rescue StandardError => e
        if @logger
                @logger.log "#{e.message}\n", :error
        else
                puts e.message
        end
        if @options[:verbose]
                p e
                puts e.backtrace
        end
        unless @variables['__DEBUG__']
                if break_into_debug and @options[:debug]
                        debug
                elsif exit_on_error
                        if @variables['__RAISE_ERROR__']
                                raise
                        else
                                exit false
                        end
                end
        end
end

with_timeout(*error_types) { || ... } click to toggle source

Executes the given block retrying for at most ${__TIMEOUT__} seconds. Note that this method does not take into account the time it takes to execute the block itself.

For example

ctx.with_timeout StandardError do
    ctx.find ('element_with_delay') do |e|
        # do something with e
    end
end

# File lib/bauxite/core/context.rb, line 288
def with_timeout(*error_types)
        stime = Time.new
        timeout ||= stime + @variables['__TIMEOUT__']
        yield
rescue *error_types => e
        t = Time.new
        rem = timeout - t
        raise if rem < 0

        @logger.progress(rem.round)

        sleep(1.0/10.0) if (t - stime).to_i < 1
        retry
end

Metadata

↑ top

Public Class Methods

action_args(action) click to toggle source

Returns an array with the names of the arguments of the specified action.

For example:

Context::action_args 'assert'
# => [ "selector", "text" ]

# File lib/bauxite/core/context.rb, line 391
def self.action_args(action)
        action += '_action' unless _action_methods.include? action
        Action.public_instance_method(action).parameters.map { |att, name| name.to_s }
end

actions() click to toggle source

Returns an array with the names of every action available.

For example:

Context::actions
# => [ "assert", "break", ... ]

# File lib/bauxite/core/context.rb, line 381
def self.actions
        _action_methods.map { |m| m.sub(/_action$/, '') }
end

loggers() click to toggle source

Returns an array with the names of every logger available.

For example:

Context::loggers
# => [ "null", "bash", ... ]

# File lib/bauxite/core/context.rb, line 420
def self.loggers
        Loggers.constants.map { |l| l.to_s.downcase.sub(/logger$/, '') }
end

max_action_name_size() click to toggle source

Returns the maximum size in characters of an action name.

This method is useful to pretty print lists of actions

For example:

# assuming actions = [ "echo", "assert", "tryload" ]
Context::max_action_name_size
# => 7

# File lib/bauxite/core/context.rb, line 444
def self.max_action_name_size
        actions.inject(0) { |s,a| a.size > s ? a.size : s }
end

parsers() click to toggle source

Returns an array with the names of every parser available.

For example:

Context::parsers
# => [ "default", "html", ... ]

# File lib/bauxite/core/context.rb, line 430
def self.parsers
        (Parser.public_instance_methods(false)                           - ParserModule.public_instance_methods(false))
        .map { |p| p.to_s }
end

selectors(include_standard_selectors = true) click to toggle source

Returns an array with the names of every selector available.

If include_standard_selectors is true (default behavior) both standard and custom selector are returned, otherwise only custom selectors are returned.

For example:

Context::selectors
# => [ "class", "id", ... ]

# File lib/bauxite/core/context.rb, line 406
def self.selectors(include_standard_selectors = true)
        ret = Selector.public_instance_methods(false).map { |a| a.to_s.sub(/_selector$/, '') }
        if include_standard_selectors
                ret += Selenium::WebDriver::SearchContext::FINDERS.map { |k,v| k.to_s }
        end
        ret
end

Variable manipulation methods

↑ top

Public Instance Methods

expand(s) click to toggle source

Recursively replaces occurencies of variable expansions in s with the corresponding variable value.

The variable expansion expression format is:

'${variable_name}'

For example:

ctx.variables = { 'a' => '1', 'b' => '2', 'c' => 'a' }
ctx.expand '${a}'    # => '1'
ctx.expand '${b}'    # => '2'
ctx.expand '${c}'    # => 'a'
ctx.expand '${${c}}' # => '1'

# File lib/bauxite/core/context.rb, line 465
def expand(s)
        result = @variables.inject(s) do |s,kv|
                s = s.gsub(/\$\{#{kv[0]}\}/, kv[1].to_s)
        end
        result = expand(result) if result != s
        result
end

with_vars(vars) { || ... } click to toggle source

Temporarily alter the value of context variables.

This method alters the value of the variables specified in the vars hash for the duration of the given block. When the block completes, the original value of the context variables is restored.

For example:

ctx.variables = { 'a' => '1', 'b' => '2', c => 'a' }
ctx.with_vars({ 'a' => '10', d => '20' }) do
   p ctx.variables
   # => {"a"=>"10", "b"=>"2", "c"=>"a", "d"=>"20"}
end
p ctx.variables
# => {"a"=>"1", "b"=>"2", "c"=>"a"}

# File lib/bauxite/core/context.rb, line 488
def with_vars(vars)
        current = @variables
        @variables = @variables.merge(vars)
        yield
ensure
        @variables = current
end