sir 0.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c2411c7dd813a1cccfe7b38b331086ff52c5fd7b
+  data.tar.gz: 1f68a77c0eafb6de9d0736c096702db61bc1653e
+SHA512:
+  metadata.gz: c43839ae12e2ebaa0d35457478b1b2501cc8d215efeae7d19313091eff26bbef61344cedb811a6a897cc2d061e4faccf22ab097902748721863ae36ee1385af9
+  data.tar.gz: 92a7868f66d2a04dd7efc481420715af3ad0ca82037909c3dcf55b19572976f4220fe3739c1b377981d3cd3effb377b092dedd3d862414c1905aec95ecb3723c

data/.gitignore

@@ -0,0 +1,20 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+*.swp
+*.swo
+*~
+*.png
+*.html

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Sergey Smagin
+
+MIT 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.
+
+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,33 @@
+# Sir
+
+Sir is Selenium InterpreteR. It allows to run your selenium tests without firefox => right on server. And it's pretty cool.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sir'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sir
+
+## Usage
+
+You can either run executable file or include as library.
+
+To run executable:
+
+    ./bin/sir path/to/file path/to/initial_state
+
+To use it inside your code:
+
+   Sir.run!(path_to_file, initial_state) 
+   #=> run commands, return hash with that commands
+

data/Rakefile

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

data/bin/sir

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/sir'
+require 'pry-byebug'
+
+file_path, initial_state_path = *ARGV
+initial_state = YAML.load_file(initial_state_path) if initial_state_path
+
+pp Sir.run!(file_path, initial_state || {})

data/lib/sir.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+require 'nokogiri'
+require 'execjs'
+require 'capybara/poltergeist'
+require_relative 'sir/capybara_ext'
+require 'pp'
+
+Capybara.register_driver :poltergeist do |app|
+  options = { timeout: 180,
+              js_errors: false,
+              phantomjs_options: ['--ignore-ssl-errors=yes'],
+              window_size: [1680, 1050] }
+  Capybara::Poltergeist::Driver.new(app, options)
+end
+Capybara.default_driver = :poltergeist
+
+module Sir
+  class << self
+    attr_accessor :state
+  end
+end
+
+require_relative 'sir/version'
+require_relative 'sir/parser'
+require_relative 'sir/wrapper'
+
+module Sir
+  def self.run!(path, initial_state = {})
+    parser = Sir::Parser.new(path, initial_state)
+    result = parser.run
+    destroy_session parser.wrapper.session rescue nil
+    result
+  end
+
+  def self.destroy_session(session)
+    session.driver.quit
+  end
+end

data/lib/sir/capybara_ext.rb

@@ -0,0 +1,12 @@
+class Capybara::Poltergeist::Browser
+  def find(method, selector)
+    result = command('find', method, selector)
+
+    # FIXME workaround for this bug https://github.com/teampoltergeist/poltergeist/issues/482
+    if result == true
+      result = command('find', method, selector)
+    end
+
+    result['ids'].map { |id| [result['page_id'], id] }
+  end
+end

data/lib/sir/parser.rb

@@ -0,0 +1,185 @@
+# Sir::Parser is class that parse html and generate commands that may be sent
+# into Capybara.
+#
+# @example
+#   Sir::Parser.new('path/to/file').parse!
+#   #=> [ { command: 'select', args: [ { id: 'ccid', label: /expire/ } ] } ]
+#
+class Sir::Parser
+  attr_reader :document, :wrapper
+
+  # Map selenium methods to wrapper's ones.
+  METHODS = YAML.load_file File.expand_path('yaml/commands_mapping.yml', __dir__)
+  NO_EQUATIONS_METHODS = %w(visit expect_location wait_for_loading)
+
+  def initialize(path, initial_state = nil, wrapper = nil)
+    @path = path
+    @document = Nokogiri::HTML File.read path
+    @wrapper = wrapper || Sir::Wrapper.new
+    @wrapper.state = initial_state if initial_state
+  end
+
+  # Make it possible to run command right from Sir::Parser.
+  #
+  def self.run!(path, initial_state = {}, wrapper = nil)
+    new(path, initial_state, wrapper).run
+  end
+
+  # Run commands from file.
+  # It makes interpretation itself.
+  #
+  def run
+    result = commands.inject([]) do |r, x|
+      begin
+        command = get_command x
+        next (r) unless command
+        r << wrapper.send_command(command)
+      rescue NoMethodError => e
+        if command[:args].last == "*[aria-label=Delete]" # workaround for gmail
+          return {
+            success: false,
+            output: (r << command),
+          }
+        else
+          binding.pry
+          return {
+            success: false,
+            output: (r << command),
+            error: { message: e.message, backtrace: e.backtrace }
+          }
+        end
+      rescue => e
+        binding.pry
+        return {
+          success: false,
+          output: (r << command),
+          error: { message: e.message, backtrace: e.backtrace }
+        }
+      end
+    end
+    failed = result.any? { |x| x[:command] == 'run' && x[:result][:success] == false }
+    { success: !failed, output: result }
+  end
+
+  # Parse one command.
+  # @param c [Nokogiri::Element] one command on selenium language.
+  #
+  def get_command(c)
+    if path = external_script_link(c)
+      { command: 'run', args: [full_path(path)] }
+    elsif title?(c)
+      nil
+    else parse_command(*c.css('td').map(&:text))
+    end
+  end
+
+  # Get commands from html structure and parse them.
+  #
+  def commands
+    document.css('tbody tr')
+  end
+
+  # Parse command from array to hash
+  #
+  # @param command [String] selenium command name
+  # @param args    [Array]  selenium arguments
+  #
+  # @example
+  #   parse_command(*["open", "${BOX}/application", ""])
+  #   #=> { command: 'visit', args: ['#http://value/of/box/application'] }
+  #
+  def parse_command(command, *args)
+    method = METHODS[command]
+    fail "Unrecognized command: #{command}" if method.nil?
+    arguments = args.reject(&:empty?).map do |line|
+      with_vars = parse_js(replace_variables(line))
+      next with_vars if NO_EQUATIONS_METHODS.include?(method)
+      EQUATION_WITH_REGEX.match(with_vars) ?
+        parse_equation_with_regex(with_vars) : parse_equation(with_vars)
+    end.flatten
+    { command: method, args: arguments }
+  end
+
+  protected
+
+  # Search link to other file in tr.
+  # @params tr [Nokogiri::Node] if fact any Nokogiri node.
+  #
+  # @returns nil when no link founded.
+  # @returns String with link if founded.
+  #
+  def external_script_link(tr)
+    tr.css('td a').map { |l| l['href'] }.first
+  end
+
+  # Check if tr is title. Title is written with bold font.
+  #
+  def title?(tr)
+    !!tr.css('td b').text[0]
+  end
+
+  # Expand path relative to path of file that we interpret.
+  #
+  # @params link [String] relative path
+  # @returns [String] full path
+  #
+  def full_path(link)
+    File.expand_path('../' + link, @path)
+  end
+
+  VARIABLE = /\$\{(\w*)\}/
+  EQUATION = /(\w*)=(.*)/
+  EQUATION_WITH_REGEX = /(\w*)=regexp:(.*)/
+  JS = /javascript\{(.*)\}/
+  ATTRIBUTE = /(.+)@([a-z\-\_]+)$/
+  PSEUDO_SELECTOR = /(.+):(.+)\('(.+)'\)/
+
+  # Replace variables that we have in state.
+  # Pattern of variable is '${var}'.
+  #
+  def replace_variables(line)
+    line.scan(VARIABLE).flatten
+      .reduce(line) { |r, x| r.gsub("${#{x}}", (wrapper.state[x] || '')) }
+  end
+
+  # Split equation into variable and value.
+  #
+  def parse_equation(line)
+    match_data = EQUATION.match(line)
+    return line unless match_data
+    left = match_data[1].to_sym
+    right = parse_pseudo_selector(match_data[2])
+    right = Array === right ? right : parse_attribute(match_data[2])
+    [left, *right]
+  end
+
+  def parse_equation_with_regex(line)
+    match_data = EQUATION_WITH_REGEX.match(line)
+    match_data ? [match_data[1].to_sym, /#{match_data[2]}/] : line
+  end
+
+  def parse_js(line)
+    match_data = JS.match(line)
+    match_data ? ExecJS.eval(match_data[1]).to_s : line
+  end
+
+  # Parse attribute. In selenium attribute is written like 'link@href'.
+  #
+  def parse_attribute(line)
+    match_data = ATTRIBUTE.match(line)
+    match_data ? match_data[1..2] : [line]
+  end
+
+  # Parse pseudo selector.
+  # For example: "div[role=link] span:contains('Purchase')"
+  #
+  def parse_pseudo_selector(line)
+    match_data = PSEUDO_SELECTOR.match(line)
+    replace_pseudo = { 'contains' => :text }
+    return line unless match_data
+    [
+      match_data[1],
+      { (replace_pseudo[match_data[2]] || match_data[2]).to_sym => match_data[3] }
+    ]
+  end
+end

data/lib/sir/version.rb

@@ -0,0 +1,3 @@
+module Sir
+  VERSION = "0.2.3"
+end

data/lib/sir/wrapper.rb

@@ -0,0 +1,347 @@
+# Capybara wrapper. Run capybara, rspec and ruby commands.
+#
+class Sir::Wrapper
+  class ExpectationError < StandardError
+    attr_accessor :message
+
+    def initialize(msg, expected, got)
+      @message = "#{msg}\n\texpected: #{expected}\n\tgot: #{got}"
+    end
+  end
+
+  attr_accessor :session, :state
+
+  def initialize(session = nil)
+    @session = session || Capybara::Session.new(:poltergeist)
+  end
+
+  # Example of hash:
+  #
+  # @example
+  #   send_command({ command: 'visit',
+  #     args: ['http://value/of/box/application'] })
+  #   #=> `visit 'http://value/of/box/application'` execution
+  #
+  def send_command(hash)
+    r = send(hash[:command], *hash[:args])
+    r = true if r == ''
+    hash.merge(result: r)
+  end
+
+  # Run script by given path.
+  #
+  # @params path [String] path to script
+  # @return hash of commands that it run.
+  #
+  def run(path)
+    Sir::Parser.run!(path, state, self)
+  end
+
+  # Wrapper of clearAllVisible cookies. Clear cookies.
+  #
+  def clean_cookies
+    session.driver.clear_cookies
+  end
+
+  # Simple capybara visit, except we use session to run it.
+  #
+  def visit(address)
+    tries ||= 0
+    session.visit address
+    try_box_crutch(address)
+    pp session.current_url
+  rescue Capybara::Poltergeist::TimeoutError => e
+    cookies = session.driver.cookies
+    session.driver.quit
+    @session = Capybara::Session.new(:poltergeist)
+    cookies.each { |k, v| session.driver.cookies[k] = v }
+    if retries < 2
+      retry
+    else
+      raise e
+    end
+  end
+
+  def try_box_crutch(address)
+    url = session.current_url
+    if address =~ /auth\/box\?content_id=(\d+)/ && !url.include?('#videos')
+      visit url + "#videos/#{$~[1]}"
+    end
+  end
+
+  # Wrapper of verifyText.
+  # @example
+  #   expect_text :id, 'user_id', 'John'
+  #
+  def expect_text(criterium, selector, text)
+    message = 'Failed to find text:'
+    expected = text
+    got = session.find(criterium, selector).text
+    fail ExpectationError.new(message, expected, got) unless expected == got
+  end
+
+  # Wrapper of assertLocation.
+  # @example
+  #   expect_location 'ya.ru'
+  #
+  def expect_location(address)
+    message = 'Failed to be on expected page:'
+    expected = address
+    got = session.current_url
+    fail ExpectationError.new(message, expected, got) unless expected == got
+  end
+
+  def expect_attribute(criterium, selector, attribute, expected)
+    tries ||= 0
+    message = 'Failed to check attribute:'
+    got = session.first(criterium, selector, visible: [true, false])[attribute]
+    fail ExpectationError.new(message, expected, got) unless File.fnmatch(expected, got)
+  rescue => e
+    if (tries < 3)
+      retry
+    else
+      raise e
+    end
+  end
+
+  # Wrapper of sleep.
+  # @example
+  #   sleep "5000" #=> do nothing 5 seconds.
+  #
+  def sleep(milliseconds)
+    Kernel.sleep(milliseconds.to_i / 1000)
+  end
+
+  # Wrapper of select.
+  # @example
+  #   select :css, '.hey.there', :id, 'username'
+  #
+  def select(*args)
+    session.find(*args.first(2)).select(args.last)
+  end
+
+  # Wrapper of type.
+  # @example
+  #   find_and_set :id, 'username', 'pahom'
+  #
+  def find_and_set(criterium, selector, value)
+    is_angular = false # !session.evaluate_script('angular').nil?
+    if selector.include?('file') && is_angular
+      angular_find_and_set selector, value
+    else
+      session.find(criterium, selector, visible: [true, false]).set value
+    end
+  end
+
+  def angular_find_and_set(selector, value)
+    sleep 1000
+    unless session.first(:id, 'fakeFileInput')
+      session.execute_script "fakeFileInput = window.$('<input/>').attr({id: 'fakeFileInput', type:'file'}).appendTo('body');"
+    end
+    session.first(:id, 'fakeFileInput').set value
+    session.execute_script("angular.element(document.getElementById('#{selector}')).scope().scanProcess.fileSelect($('#fakeFileInput')[0].files)")
+    sleep 5000
+  end
+
+  # Wrapper of click.
+  # @example
+  #   find_and_click :id, 'submit_form'
+  #
+  def find_and_click(criterium, *selectors)
+    tries ||= 0
+    session.first(criterium, *selectors, visible: [true, false]).click
+  rescue Capybara::Poltergeist::ObsoleteNode
+    sleep 1000
+    session.evaluate_script("$('#{selectors.join(' ')}').show()")
+    session.first(criterium, *selectors).click
+  rescue => e
+    if (tries < 3)
+      retry
+    else
+      raise e
+    end
+  end
+
+  # Same as find_and_click, but sleep 5 seconds after it.
+  # what the hell should it do in selenium?
+  #
+  def click_and_wait(criterium, *selectors)
+    sleep 2000
+    session.first(criterium, *selectors).click
+  rescue
+    case criterium
+    when :css then session.evaluate_script("$('#{selectors.join(' ')}').show()")
+    when :id then session.evaluate_script("$('##{selectors.join(' ')}').show()")
+    end
+    session.first(criterium, *selectors).click
+  ensure
+    sleep 5000
+  end
+
+  # Add url to global state. Wrapper of storeLocation.
+  #
+  def state_set_url(name)
+    state[name] = session.current_url
+  end
+
+  # Wrapper of storeText. Add finded text to global state.
+  # @example
+  #   state_set_text :id, 'username', 'user_name'
+  #
+  def state_set_text(*args)
+    case args.size
+    when 2
+      criterium, selector, name = :xpath, *args
+    when 3
+      criterium, selector, name = *args
+    end
+    sleep 500
+    # workaround for purchase tickets.
+    if %w(with_membership without_membership).include?(selector)
+      text = (session.first(:id, 'with_membership') || session.first(:id, 'without_membership')).text
+    else
+      text = session.first(criterium, selector, visible: [true, false]).text
+      if text == true
+        text = session.first(criterium, selector, visible: [true, false]).text
+      end
+    end
+    state[name] = text
+  end
+
+  # Wrapper of storeAttribute. Add text at attribute to global state.
+  # @example
+  #   state_set_text :id, 'username', 'href', 'user_name'
+  #
+  def state_set_attribute(criterium, selector, attribute, name)
+    x ||= 0
+    text = session.first(criterium, selector, visible: [true, false])[attribute]
+    state[name] = text
+  rescue
+    (x += 1; retry) if x < 3
+  end
+
+  def state_set_eval(code, name)
+    state[name] = session.evaluate_script(code)
+  end
+
+  def state_set(value, name)
+    state[name] = value
+  end
+
+  def keyup(criterium, selector, keycode)
+    selector = case criterium
+               when :css then selector
+               when :id then '#' + selector
+               else selector
+               end
+    keypress_script = "var e = $.Event('keyup', { keyCode: #{keycode} }); $('#{selector}').trigger(e);"
+    session.execute_script(keypress_script)
+  end
+
+  def wait_for_loading(address)
+    # session.visit address
+    sleep 5000
+    wait_for { File.fnmatch(address, session.current_url) }
+  end
+
+  # Wrapper of waitForElementPresent.
+  # @example
+  #   wait_for_element :id, 'username'
+  #
+  def wait_for_element(criterium, *selectors)
+    wait_for { session.first(criterium, *selectors, visible: [true, false]) }
+    true
+  rescue Timeout::Error
+    url = session.current_url
+    url = session.current_url unless String === url
+    session.visit url
+    sleep 10000
+    session.first(criterium, *selectors, visible: [true, false])
+  ensure
+    true
+  end
+
+  # Wrapper of waitForVisible.
+  # @example
+  #   wait_for_visible :id, 'username'
+  #
+  def wait_for_visible(criterium, selector, value = nil)
+    wait_for do
+      element = session.first(criterium, selector, visible: [true])
+      if element && value
+        File.fnmatch(value.to_s, element.text)
+      else
+        true
+      end
+    end
+  end
+
+  # Wrapper of waitForText.
+  # @example
+  #   wait_for_text :id, 'username', 'Pahom'
+  #
+  def wait_for_text(criterium, *selectors, text)
+    wait_for do
+      (x = session.first(criterium, *selectors, visible: [true, false])) &&
+        File.fnmatch(text, x.text)
+    end
+  rescue
+    # Fucking poltergeist can do this:
+    # [42] pry(#<Sir::Parser>)> wrapper.session.text
+    # NoMethodError: undefined method `map' for nil:NilClass
+    # from /home/s/work/sir/lib/sir/capybara_ext.rb:10:in `find'
+    # [43] pry(#<Sir::Parser>)> wrapper.session.text
+    # => "true"
+    # [44] pry(#<Sir::Parser>)> wrapper.session.current_url
+    # => "+You\nSearch\nImages\nMaps\nPlay\nYouTube\nGmail\nDrive\nMore\nrmtest011@gmail.com\n×\n\tA faster way to browse the web\nInstall Google Chrome\n\nRussia\n\n \t\n\n\nAdvanced search\nLanguage tools\n\nGoogle.ru offered in: русском\nAdvertising ProgramsAbout GoogleGoogle.com\n© 2015 - Privacy - Terms\n\n"
+    # FIXME: so just sleep 5 seconds and hope it will be fine.
+    sleep 5000
+  end
+
+  def wait_for_text_present(text)
+    wait_for do
+      session.text.include? text
+    end
+  end
+
+  # Wrapper of waitForValue.
+  # @example
+  #   wait_for_value :id, 'username', 'Pahom'
+  #
+  def wait_for_value(criterium, selector, text)
+    wait_for do
+      session.first(criterium, selector, text)
+    end
+    true
+  end
+
+  def wait_for_content(content)
+    wait_for(CONTENT_TIMEOUT) { session.has_text? content }
+  end
+
+  def wait_for_ajax
+    previous = active_queries_count
+    wait_for(AJAX_TIMEOUT) { active_queries_count < previous }
+  end
+
+  protected
+
+  AJAX_TIMEOUT = 100
+  CONTENT_TIMEOUT = 100
+  STANDARD_TIMEOUT = 50
+
+  def wait_for(timeout = STANDARD_TIMEOUT)
+    result = nil
+    Timeout.timeout(timeout) do
+      loop do
+        sleep 1
+        break if result = yield
+      end
+    end
+    result
+  end
+
+  def active_queries_count
+    session.evaluate_script('jQuery.active')
+  end
+end

data/lib/sir/yaml/commands_mapping.yml

@@ -0,0 +1,24 @@
+open: visit
+pause: sleep
+select: select
+type: find_and_set
+click: find_and_click
+clickAt: find_and_click
+clickAndWait: click_and_wait
+waitForElementPresent: wait_for_element
+waitForLocation: wait_for_loading
+waitForText: wait_for_text
+waitForTextPresent: wait_for_text_present
+waitForValue: wait_for_value
+waitForVisible: wait_for_visible
+storeAttribute: state_set_attribute
+storeLocation: state_set_url
+storeText: state_set_text
+storeEval: state_set_eval
+store: state_set
+gotolabel: goto_label
+verifyText: expect_text
+verifyAttribute: expect_attribute
+assertLocation: expect_location
+deleteAllVisibleCookies: clean_cookies
+keyUp: keyup

data/sir.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sir/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sir"
+  spec.version       = Sir::VERSION
+  spec.authors       = ["Sergey Smagin"]
+  spec.email         = ["smaginsergey1310@gmail.com"]
+  spec.summary       = %q{Run selenium tests with webkit. Headless.}
+  spec.license       = "MIT"
+
+  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.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "rspec"
+  spec.add_dependency "poltergeist"
+  spec.add_dependency "nokogiri"
+  spec.add_dependency "execjs"
+  spec.add_dependency "therubyracer"
+end

data/spec/fixtures/commands.yml

@@ -0,0 +1,60 @@
+:open:
+  :input: ['open', '${BOX}/application']
+  :result:
+    :command: visit
+    :args: [ 'box/application' ]
+:pause:
+  :input: ['pause', '5000']
+  :result:
+    :command: sleep
+    :args: [ '5000' ]
+:select:
+  :input: ['select', 'id=ccid', 'label=regexp:.*expire.*']
+  :result:
+    :command: select
+    :args: [ !ruby/sym id, 'ccid', !ruby/sym label, !ruby/regexp /.*expire.*/ ]
+:find_and_set:
+  :input: ['type', 'id=amount', 'attestationAmount']
+  :result:
+    :command: find_and_set
+    :args: [ !ruby/sym id, 'amount', 'attestationAmount' ]
+:click:
+  :input: ['click', "xpath=(//input[@name='can-share'])[2]"]
+  :result:
+    :command: find_and_click
+    :args: [ !ruby/sym xpath, "(//input[@name='can-share'])[2]" ]
+:click_and_wait:
+  :input: ['clickAndWait', "xpath=(//input[@name='can-share'])[2]"]
+  :result:
+    :command: click_and_wait
+    :args: [ !ruby/sym xpath, "(//input[@name='can-share'])[2]" ]
+:wait_for_element:
+  :input: ['waitForElementPresent', 'css=.icos']
+  :result:
+    :command: wait_for_element
+    :args: [ !ruby/sym css, '.icos' ]
+:wait_for_loading:
+  :input: ['waitForLocation', '${BOX}/account/attestate']
+  :result:
+    :command: wait_for_loading
+    :args: [ 'box/account/attestate' ]
+:wait_for_text:
+  :input: ['waitForText', 'css=h6.fcolor-green', 'Credit card approved']
+  :result:
+    :command: wait_for_text
+    :args: [ !ruby/sym css, 'h6.fcolor-green', 'Credit card approved' ]
+:state_set_url:
+  :input: ['storeLocation', 'verify']
+  :result:
+    :command: state_set_url
+    :args: [ 'verify' ]
+:state_set_text:
+  :input: ['storeText', 'css=td.def', 'attestationAmount']
+  :result:
+    :command: state_set_text
+    :args: [ !ruby/sym css, 'td.def', 'attestationAmount' ]
+:expect_text:
+  :input: ['verifyText', 'css=button', 'I accept agreement']
+  :result:
+    :command: expect_text
+    :args: [ !ruby/sym css, 'button', 'I accept agreement' ]

data/spec/fixtures/commands_info.yml

@@ -0,0 +1,4 @@
+:commands_amount: 31
+:first_command:
+  :command: visit
+  :args: [box/application]

data/spec/fixtures/initial_state.yml

@@ -0,0 +1,16 @@
+LV: "http://lv.gtflix.com"
+IDCERT: "https://gtfpass.gtflix.com"
+PAYGATE: "https://paygate.gtflix.com"
+BOX: "https://box.gtflix.com:9090"
+CART: "http://cart.gtflix.com"
+QA: "http://qa.gtflix.com"
+CM2: "http://devcm2.gtflix.com"
+gmailAccount: "amorpro3"
+CCHolderName: "John Doe"
+CCNumber: "4000000000000002"
+CCCVV: "123"
+CCYear: "2017"
+CCMonth: "01"
+cm2_user: "dan"
+cm2_pass: "qwe123"
+ 

data/spec/fixtures/line_with_equation.yml

@@ -0,0 +1,5 @@
+:in: key=value
+:out: [!ruby/sym key, 'value']
+:incorrect_in: key value whatever
+:with_attr: key=value@hi
+:out_with_attr: [!ruby/sym key, 'value', 'hi']

data/spec/fixtures/line_with_regex.yml

@@ -0,0 +1,5 @@
+:in: key=regexp:.*value.*
+:out:
+  - !ruby/sym key
+  - !ruby/regexp /.*value.*/
+:incorrect_in: key value whatever

data/spec/fixtures/line_with_variable.yml

@@ -0,0 +1,8 @@
+:state:
+  BOX: box
+  LV: lv
+:in: '${BOX}/vasya/${LV}'
+:out: 'box/vasya/lv'
+:incorrect_in: '${BOX}/vasya/${lv}'
+:incorrect_out: 'box/vasya/'
+

data/spec/fixtures/short_test_result.yml

@@ -0,0 +1,27 @@
+---
+:success: true
+:output:
+- :command: visit
+  :args:
+  - http://ya.ru
+  :result:
+    status: success
+- :command: find_and_click
+  :args:
+  - :id
+  - text
+  :result:
+    position:
+      x: 437
+      y: 353
+- :command: find_and_set
+  :args:
+  - :id
+  - text
+  - good for you
+  :result: true
+- :command: click_and_wait
+  :args:
+  - :css
+  - button.button_theme_websearch
+  :result: 0

data/spec/parser_spec.rb

@@ -0,0 +1,137 @@
+require_relative 'spec_helper'
+
+describe Sir::Parser do
+  let(:state) { Sir::Fixtures::LINE_WITH_VARIABLE[:state] }
+  let(:path) { File.expand_path '../fixtures/commands.html', __FILE__ }
+  subject    { Sir::Parser.new(path, state) }
+
+  describe '.get_commands' do
+    it 'Get as many commands as file have' do
+      expect(subject.get_commands.size).
+        to eq(Sir::Fixtures::COMMANDS_INFO[:commands_amount])
+    end
+
+    it 'Get first command properly' do
+      expect(subject.get_commands.first).
+        to eq(Sir::Fixtures::COMMANDS_INFO[:first_command])
+    end
+  end
+
+  describe '.replace_variables' do
+    it 'can replace varible like #{YO}' do
+      input = Sir::Fixtures::LINE_WITH_VARIABLE[:in]
+      out = Sir::Fixtures::LINE_WITH_VARIABLE[:out]
+      expect(subject.send(:replace_variables, input)).to eq(out)
+    end
+
+    it 'can handle incorrect variables' do
+      input = Sir::Fixtures::LINE_WITH_VARIABLE[:incorrect_in]
+      out = Sir::Fixtures::LINE_WITH_VARIABLE[:incorrect_out]
+      expect(subject.send(:replace_variables, input)).to eq(out)
+    end
+  end
+
+  describe '.parse_equation' do
+    it 'can split variables with equation' do
+      input = Sir::Fixtures::LINE_WITH_EQUATION[:in]
+      out = Sir::Fixtures::LINE_WITH_EQUATION[:out]
+      expect(subject.send(:parse_equation, input)).to eq(out)
+    end
+
+    it 'can handle incorrect variables' do
+      input = Sir::Fixtures::LINE_WITH_EQUATION[:incorrect_in]
+      out = Sir::Fixtures::LINE_WITH_EQUATION[:incorrect_in]
+      expect(subject.send(:parse_equation, input)).to eq(out)
+    end
+
+    it 'parse attributes' do
+      input = Sir::Fixtures::LINE_WITH_EQUATION[:with_attr]
+      out = Sir::Fixtures::LINE_WITH_EQUATION[:out_with_attr]
+      expect(subject.send(:parse_equation, input)).to eq(out)
+    end
+  end
+
+  describe '.parse_equation_with_regex' do
+    it 'can split variables with equation' do
+      input = Sir::Fixtures::LINE_WITH_REGEX[:in]
+      out = Sir::Fixtures::LINE_WITH_REGEX[:out]
+      expect(subject.send(:parse_equation_with_regex, input)).to eq(out)
+    end
+
+    it 'can handle incorrect variables' do
+      input = Sir::Fixtures::LINE_WITH_REGEX[:incorrect_in]
+      out = Sir::Fixtures::LINE_WITH_REGEX[:incorrect_in]
+      expect(subject.send(:parse_equation_with_regex, input)).to eq(out)
+    end
+  end
+
+  describe '.parse_command' do
+    it 'parse "open ${BOX}/application"' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:open][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:open][:result])
+    end
+
+    it 'parse pause' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:pause][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:pause][:result])
+    end
+
+    it 'parse select' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:select][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:select][:result])
+    end
+
+    it 'parse click' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:click][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:click][:result])
+    end
+
+    it 'parse click_and_wait' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:click_and_wait][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:click_and_wait][:result])
+    end
+
+    it 'parse wait_for_element' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:wait_for_element][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:wait_for_element][:result])
+    end
+
+    it 'parse wait_for_loading' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:wait_for_loading][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:wait_for_loading][:result])
+    end
+
+    it 'parse wait_for_text' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:wait_for_text][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:wait_for_text][:result])
+    end
+
+    it 'parse state_set_url' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:state_set_url][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:state_set_url][:result])
+    end
+
+    it 'parse state_set_text' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:state_set_text][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:state_set_text][:result])
+    end
+
+    it 'parse expect_text' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:expect_text][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:expect_text][:result])
+    end
+
+    it 'parse find_and_set' do
+      expect(subject.parse_command(*Sir::Fixtures::COMMANDS[:find_and_set][:input])).
+        to eq(Sir::Fixtures::COMMANDS[:find_and_set][:result])
+    end
+  end
+
+  context '#run' do
+    it 'summarize script work' do
+      path = File.expand_path 'fixtures/short_test.html', __dir__
+      expect(Sir::Parser.run!(path)).to eq(Sir::Fixtures::SHORT_TEST_RESULT)
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+require_relative '../lib/sir'
+require_relative 'support/fixtures'

data/spec/support/fixtures.rb

@@ -0,0 +1,14 @@
+require 'yaml'
+
+# When this file is loaded, for each fixture file, a singleton method is
+# created within the Sir::Fixtures module with the same name as the fixture
+# file, returning the value of the fixture.
+#
+module Sir::Fixtures; end
+
+fixtures_path = File.expand_path('../../fixtures', __FILE__)
+
+Dir[File.expand_path('*.yml', fixtures_path)].each do |filename|
+  const_name = File.basename(filename, '.*').upcase
+  Sir::Fixtures.const_set(const_name, YAML.load_file(filename))
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: sir
+version: !ruby/object:Gem::Version
+  version: 0.2.3
+platform: ruby
+authors:
+- Sergey Smagin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: poltergeist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: execjs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: therubyracer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- smaginsergey1310@gmail.com
+executables:
+- sir
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/sir
+- lib/sir.rb
+- lib/sir/capybara_ext.rb
+- lib/sir/parser.rb
+- lib/sir/version.rb
+- lib/sir/wrapper.rb
+- lib/sir/yaml/commands_mapping.yml
+- sir.gemspec
+- spec/fixtures/commands.html
+- spec/fixtures/commands.yml
+- spec/fixtures/commands_info.yml
+- spec/fixtures/initial_state.yml
+- spec/fixtures/line_with_equation.yml
+- spec/fixtures/line_with_regex.yml
+- spec/fixtures/line_with_variable.yml
+- spec/fixtures/short_test.html
+- spec/fixtures/short_test_result.yml
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Run selenium tests with webkit. Headless.
+test_files:
+- spec/fixtures/commands.html
+- spec/fixtures/commands.yml
+- spec/fixtures/commands_info.yml
+- spec/fixtures/initial_state.yml
+- spec/fixtures/line_with_equation.yml
+- spec/fixtures/line_with_regex.yml
+- spec/fixtures/line_with_variable.yml
+- spec/fixtures/short_test.html
+- spec/fixtures/short_test_result.yml
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures.rb
+has_rdoc: