lopata 0.0.16 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cd685207d7486c0cda7d76e5bbb0276b5af0e0ff73446e4d6866b49e5a8dbc5
-  data.tar.gz: 54350543eddacf904531c311dd301858ae4cb42830edef735daed97417956b42
+  metadata.gz: 4ad9bc72f5e0429f18b12bc247e3fbf4346278b5c6b487a02c665e3c020bd5f7
+  data.tar.gz: bde38469c56e1ef03b1480fa09d9d879867660983fcd9abe807ee8be553aaaed
 SHA512:
-  metadata.gz: 34ac0e832ac235f88371a44773a9f2df2f87b8099d9857300761dcf4ba6fc81da2386988684253d80e2d4d423457cd6b60e59cf152895b44468276ae1c667284
-  data.tar.gz: e287063637735bf244f351396457f07857426fc568d269e6be6fd1de07f94df18c5bd29cca3aa53c8ffd1c81007f9c0b64c5cd4d96616d441f8f143611e300b7
+  metadata.gz: ba6f140682c330ca68eb2a8d3f27aed552bd376c1a1c773ebe1914b4738da39adfe500a4254e06c2ea3865bd5fedc7246e5301eca6e130683bc4119e7db30071
+  data.tar.gz: 0d6b7e1f4ae029539a1c65fd0e9ca4546610bbe6e8da8b37250ec71a106cc3cfe0445b4a6b299de9cbd5a2b1a5e4949b7bad6f178af32e702252755553b69474

data/exe/lopata

@@ -1,4 +1,11 @@
 #!/usr/bin/env ruby
 require 'bundler/setup'
 require_relative '../lib/lopata/runner'
-Lopata::Runner.start ARGV
+
+# use default command with arguments if given command is unknown.
+argv = ARGV.dup
+unless Lopata::Runner.all_commands.keys.include? argv
+  argv.unshift 'test'
+end
+
+Lopata::Runner.start argv

data/lib/lopata.rb

@@ -1,13 +1,20 @@
 require 'lopata/id'
 require 'lopata/config'
+require 'lopata/scenario_builder'
 require 'lopata/scenario'
+require 'lopata/step'
+require 'lopata/shared_step'
 
 module Lopata
   def self.define(*args, &block)
-    Lopata::Scenario.define(*args, &block)
+    Lopata::ScenarioBuilder.define(*args, &block)
   end
 
   def self.xdefine(*args, &block)
-    Lopata::Scenario.xdefine(*args, &block)
+    Lopata::ScenarioBuilder.xdefine(*args, &block)
+  end
+
+  def self.shared_step(name, &block)
+    Lopata::SharedStep.register(name, &block)
   end
 end

data/lib/lopata/config.rb

@@ -7,7 +7,9 @@ module Lopata
 
     def init(env)
       require 'yaml'
-      @config = YAML::load(File.open("./config/environments/#{env}.yml")) || {}
+      @config = {}
+      config_filename = "./config/environments/#{env}.yml"
+      @config = YAML::load(File.open(config_filename)) if File.exists?(config_filename)
       init_db
       @role_descriptions ||= {}
       # init_includes
@@ -89,5 +91,9 @@ module Lopata
     def initialize_test
       @before_start.call if @before_start
     end
+
+    def world
+      @world ||= Lopata::World.new
+    end
   end
 end

data/lib/lopata/generators/app.rb

@@ -14,6 +14,7 @@ module Lopata
         template '.rspec', "#{name}/.rspec"
         template 'config/environments/qa.yml', "#{name}/config/environments/qa.yml"
         template 'config/initializers/capybara.rb', "#{name}/config/initializers/capybara.rb"
+        template 'spec/spec_helper.rb', "#{name}/spec/spec_helper.rb"
       end
 
       def init_dirs
@@ -21,7 +22,7 @@ module Lopata
           empty_directory "#{name}/app/#{dir}"
         end
 
-        %w{spec config/initializers}.each do |dir|
+        %w{scenarios shared_steps config/initializers}.each do |dir|
           empty_directory "#{name}/#{dir}"
         end
       end

data/lib/lopata/generators/templates/.rspec

@@ -1,2 +1,3 @@
 --color
 --format documentation
+--require spec_helper

data/lib/lopata/generators/templates/Gemfile

@@ -2,8 +2,8 @@
 gem 'selenium-webdriver'
 gem 'rspec', :require => 'spec'
 gem 'rake'
-gem 'activerecord', '~> 4.2.0'
-gem 'capybara', '~> 2.2.1' # fix capybara version to avoid capybara-angular deprication varnings.
+gem 'activerecord', '~> 6.0.2'
+gem 'capybara', '~> 3.11.1'
 gem 'thor'
-<% require "lopata/rspec/version" %>
-gem 'lopata', '<%= Lopata::RSpec::Version::STRING %>'
+<% require "lopata/version" %>
+gem 'lopata', '<%= Lopata::Version::STRING %>'

data/lib/lopata/generators/templates/Lopatafile

@@ -6,6 +6,7 @@ require 'rubygems'
 require 'bundler/setup'
 require 'active_support/all'
 require 'capybara'
+require 'capybara/dsl'
 require 'selenium/webdriver'
 require 'fileutils'
 require 'active_support'

data/lib/lopata/generators/templates/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+Lopata::Config.role_descriptions = { user: 'User' }
+Lopata::Config.default_role = :user

data/lib/lopata/observers.rb

@@ -0,0 +1,4 @@
+module Lopata::Observers
+  autoload :BaseObserver, 'lopata/observers/base_observer.rb'
+  autoload :ConsoleOutputObserver, 'lopata/observers/console_output_observer.rb'
+end

data/lib/lopata/observers/base_observer.rb

@@ -0,0 +1,23 @@
+module Lopata
+  module Observers
+    class BaseObserver
+      def started(world)
+      end
+
+      def finished(world)
+      end
+
+      def scenario_started(scenario)
+      end
+
+      def scenario_finished(scenario)
+      end
+
+      def step_started(step)
+      end
+
+      def step_finished(step)
+      end
+    end
+  end
+end

data/lib/lopata/observers/console_output_observer.rb

@@ -0,0 +1,62 @@
+module Lopata
+  module Observers
+    class ConsoleOutputObserver < BaseObserver
+      def finished(world)
+        total = world.scenarios.length
+        statuses = world.scenarios.map(&:status)
+        counts = statuses.uniq.map do |status|
+          colored("%d %s", status) % [statuses.count { |s| s == status }, status]
+        end
+        details = counts.empty? ? "" : "(%s)" % counts.join(', ')
+        puts "#{total} scenario%s %s" % [total == 1 ? '' : 's', details]
+      end
+
+      def step_finished(step)
+        @failed_steps << step if step.failed?
+      end
+
+      def scenario_started(scenario)
+        @failed_steps = []
+      end
+
+      def scenario_finished(scenario)
+        message = "#{scenario.title} #{bold(scenario.status.to_s.upcase)}"
+        puts colored(message, scenario.status)
+
+        @failed_steps.each do |step|
+          if step.exception
+            puts step.exception.message
+            puts step.exception.backtrace.join("\n")
+            puts
+          end
+        end
+      end
+
+      private
+
+      def colored(text, status)
+        case status
+        when :failed then red(text)
+        when :passed then green(text)
+        else text
+        end
+      end
+
+      def red(text)
+        wrap(text, 31)
+      end
+
+      def green(text)
+        wrap(text, 32)
+      end
+
+      def bold(text)
+        wrap(text, 1)
+      end
+
+      def wrap(text, code)
+        "\e[#{code}m#{text}\e[0m"
+      end
+    end
+  end
+end

data/lib/lopata/runner.rb

@@ -1,6 +1,9 @@
 require 'thor'
 require_relative 'generators/app'
 require_relative 'config'
+require_relative 'world'
+require_relative '../lopata'
+require_relative 'observers'
 
 module Lopata
   class Runner < Thor
@@ -13,35 +16,47 @@ module Lopata
     option :build, aliases: 'b'
     option :keep, type: :boolean, aliases: 'k'
     option :text, aliases: 't'
-    def test
-      require 'rspec'
-
-      Dir["./spec/support/**/*.rb"].sort.each { |f| require f}
-      ENV['HOME'] = File.absolute_path('.') # disable warning on rspec loading on windows
-      Lopata::Config.ops = {
-        focus: options[:focus],
-        rerun: options[:rerun],
-        users: options[:users],
-        build: options[:build],
-        env:   options[:env],
-        keep:  options[:keep],
-        text:  options[:text]
-      }
-      Lopata::Config.init(options[:env])
-      Lopata::Config.initialize_test
-      Lopata::Config.init_rspec
-
-      ::RSpec::Core::Runner.run ['spec']
+    def test(*args)
+      configure_from_options
+
+      # Dir["./spec/support/**/*.rb"].sort.each { |f| require f}
+      world = Lopata::Config.world
+      world.setup_observers
+      world.load_shared_steps
+      world.load_scenarios(*args)
+      world.scenarios.each { |s| s.run }
+      world.finish
     end
 
     default_task :test
 
     register Generators::App, :new, 'lopata new project-name', 'Init new lopata projects'
+
+    def self.exit_on_failure?
+      true
+    end
+
+    no_commands do
+      def configure_from_options
+        Lopata::Config.ops = {
+          focus: options[:focus],
+          rerun: options[:rerun],
+          users: options[:users],
+          build: options[:build],
+          env:   options[:env],
+          keep:  options[:keep],
+          text:  options[:text]
+        }
+        Lopata::Config.init(options[:env])
+        Lopata::Config.initialize_test
+        # ENV['HOME'] = File.absolute_path('.') # disable warning on rspec loading on windows
+        # Lopata::Config.init_rspec
+      end
+    end
   end
 end
 
 unless ARGV.first == 'new'
-  raise 'No Lopatafile found in running dir' unless File.exists?('./Lopatafile')
-  eval File.binread('./Lopatafile')
+  eval File.binread('./Lopatafile') if File.exists?('./Lopatafile')
 end
 

data/lib/lopata/scenario.rb

@@ -1,169 +1,47 @@
-class Lopata::Scenario
-  def self.define(title = nil, metadata = nil, &block)
-    scenario = new
-    scenario.title(title) if title
-    scenario.metadata(metadata) if metadata
-    scenario.instance_exec &block
-    scenario.build_rspec
-  end
-
-  # Do noting. Exclude defined scenario from suite.
-  def self.xdefine(*attrs)
-  end
-
-  def build_rspec
-    option_combinations.each do |option_set|
-      args = prepare_args(option_set)
-      raise "scenario required a name in first argument" unless args.first.is_a? String
-      steps = @steps
-      spec = RSpec.describe(*args)
-      spec.send :extend, RSpecInjections
-      spec.nested_with_as(*args) do
-        steps.each do |block|
-          instance_exec &block
-        end
-        if Lopata::Config.after_scenario
-          instance_exec &Lopata::Config.after_scenario
-        end
-      end
-    end
-  end
-
-  def as(*args, &block)
-    @roles = args.flatten
-    @roles << CalculatedValue.new(&block) if block_given?
-    @role_options = nil
-  end
-
-  def role_options
-    @role_options ||= build_role_options
-  end
-
-  def metadata(hash)
-    raise 'metadata expected to be a Hash' unless hash.is_a?(Hash)
-    @common_metadata ||= {}
-    @common_metadata.merge! hash
-  end
-
-  def without_user
-    @without_user = true
-  end
+require 'rspec/expectations'
 
-  def skip_when(&block)
-    @skip_when = block
-  end
-
-  def skip?(option_set)
-    @skip_when && @skip_when.call(option_set)
-  end
+class Lopata::Scenario
+  include RSpec::Matchers
 
-  %i{setup action it context teardown include_context include_examples}.each do |name|
-    name_if = "%s_if" % name
-    name_unless = "%s_unless" % name
-    define_method name, ->(*args, &block) { add_step(name, *args, &block) }
-    define_method name_if, ->(condition, *args, &block) { add_if_step(name, condition, *args, &block) }
-    define_method name_unless, ->(condition, *args, &block) { add_unless_step(name, condition, *args, &block) }
-  end
+  attr_reader :title, :metadata, :steps, :status
 
-  def cleanup(*args, &block)
-    add_step_as_is(:cleanup, *args, &block)
+  def initialize(*args)
+    @title = args.first
+    @metadata = args.last.is_a?(Hash) ? args.last : {}
+    @steps = []
+    @status = :not_runned
   end
 
-  def add_step(method_name, *args, &block)
-    @steps ||= []
-    @steps << Proc.new do
-      # will be called in context of rspec group
-      flat_args = args.flatten
-      flat_args = Lopata::Scenario.separate_args(flat_args) if method_name =~ /^(setup|action)/
-      converted_args = Lopata::Scenario.convert_args(metadata, *flat_args)
-      send method_name, *converted_args, &block
-    end
+  def run
+    @status = :running
+    world.notify_observers(:scenario_started, self)
+    teardown_steps = []
+    @steps.reject(&:teardown?).each { |step| step.run(self) }
+    @steps.select(&:teardown?).each { |step| step.run(self) }
+    @status = @steps.all?(&:passed?) ? :passed : :failed
+    world.notify_observers(:scenario_finished, self)
   end
 
-  def add_if_step(method_name, condition, *args, &block)
-    @steps ||= []
-    @steps << Proc.new do
-      # will be called in context of rspec group
-      if match_metadata?(condition)
-        flat_args = args.flatten
-        flat_args = Lopata::Scenario.separate_args(flat_args) if method_name =~ /^(setup|action)/
-        converted_args = Lopata::Scenario.convert_args(metadata, *flat_args)
-        send method_name, *converted_args, &block
-      end
-    end
-  end
-
-  def add_unless_step(method_name, condition, *args, &block)
-    @steps ||= []
-    @steps << Proc.new do
-      # will be called in context of rspec group
-      unless match_metadata?(condition)
-        flat_args = args.flatten
-        flat_args = Lopata::Scenario.separate_args(flat_args) if method_name =~ /^(setup|action)/
-        converted_args = Lopata::Scenario.convert_args(metadata, *flat_args)
-        send method_name, *converted_args, &block
-      end
-    end
-  end
-
-  def add_step_as_is(method_name, *args, &block)
-    @steps ||= []
-    @steps << Proc.new do
-      # do not convert args - symbols mean name of instance variable
-      send method_name, *args, &block
-    end
-  end
-
-  def let_metadata(*keys)
-    @steps ||= []
-    @steps << Proc.new do
-      m = metadata
-      keys.each do |key|
-        define_method key do
-          m[key]
-        end
-
-        define_singleton_method key do
-          m[key]
-        end
-      end
+  def match_metadata?(metadata_key)
+    case metadata_key
+    when Hash
+      metadata_key.keys.all? { |k| metadata[k] == metadata_key[k] }
+    when Array
+      metadata_key.map { |key| metadata[key] }.none?(&:nil?)
+    else
+      metadata[metadata_key]
     end
   end
 
-  def let_method(method_name, &block)
-    @steps ||= []
-    @steps << Proc.new do
-      define_method method_name, &block
-      define_singleton_method method_name, &block
-    end
+  def run_step(method_name, *args, &block)
+    instance_exec(&block)
   end
 
-  def steps(&block)
-    @steps ||= []
-    @steps << block
+  def world
+    @world ||= Lopata::Config.world
   end
 
-  def steps_if(metadata_key, &block)
-    @steps ||= []
-    @steps << Proc.new do
-      if match_metadata?(metadata_key)
-        instance_exec &block
-      end
-    end
-  end
-  alias steps_for steps_if
-
-  def steps_unless(metadata_key, &block)
-    @steps ||= []
-    @steps << Proc.new do
-      unless match_metadata?(metadata_key)
-        instance_exec &block
-      end
-    end
-  end
-  alias steps_for_not steps_unless
-
-  def self.convert_args(metadata, *args)
+  def convert_args(*args)
     args.map do |arg|
       case arg
         # trait symbols as link to metadata.
@@ -174,220 +52,25 @@ class Lopata::Scenario
     end.flatten
   end
 
-  def self.separate_args(args)
+  def separate_args(args)
     args.map { |a| a.is_a?(String) && a =~ /,/ ? a.split(',').map(&:strip) : a }.flatten
   end
 
-  def build_role_options
-    return [] unless roles
-    [Diagonal.new(:as, roles.map { |r| [nil, r] })]
-  end
-
-  def roles
-    return false if @without_user
-    @roles ||= [Lopata::Config.default_role].compact
-  end
-
-  def title(value)
-    @title = value
-  end
-
-  def option(metadata_key, variants)
-    options << Option.new(metadata_key, variants)
-  end
-
-  def diagonal(metadata_key, variants)
-    diagonals << Diagonal.new(metadata_key, variants)
-  end
-
-  def options
-    @options ||= []
-  end
-
-  def diagonals
-    @diagonals ||= []
-  end
-
-  def option_combinations
-    combinations = combine([OptionSet.new], options + diagonals + role_options)
-    while !(diagonals + role_options).all?(&:complete?)
-      combinations << OptionSet.new(*(options + diagonals + role_options).map(&:next_variant))
-    end
-    combinations.reject { |option_set| skip?(option_set) }
-  end
-
-  def combine(source_combinations, rest_options)
-    # raise 'source_combinations cannot be empty' if source_combinations.blank?
-    return source_combinations if rest_options.blank?
-    combinations = []
-    current_option = rest_options.shift
-    source_combinations.each do |source_variants|
-      current_option.level_variants.each do |v|
-        combinations << (source_variants + OptionSet.new(v))
-      end
-    end
-    combine(combinations, rest_options)
-  end
-
-  def prepare_args(option_set, *args)
-    options_title, metadata = option_set.title, option_set.metadata
-    if args[0].is_a? String
-      args[0] = [@title, options_title, args[0]].reject(&:blank?).join(' ')
-    else
-      args.unshift([@title, options_title].reject(&:blank?).join(' '))
-    end
-
-    metadata.merge!(@common_metadata) if @common_metadata
-
-    if args.last.is_a? Hash
-      args.last.merge!(metadata)
-    else
-      args << metadata
-    end
-    args
+  def failed?
+    status == :failed
   end
 
-  # Набор вариантов, собранный для одного теста
-  class OptionSet
-    attr_reader :variants
-    def initialize(*variants)
-      @variants = {}
-      variants.each { |v| self << v }
-    end
-
-    def +(other_set)
-      self.class.new(*@variants.values).tap do |sum|
-        other_set.each { |v| sum << v }
-      end
-    end
+  private
 
-    def <<(variant)
-      @variants[variant.key] = variant
-    end
-
-    def [](key)
-      @variants[key]
-    end
-
-    def each(&block)
-      @variants.values.each(&block)
-    end
-
-    def title
-      @variants.values.map(&:title).compact.join(' ')
-    end
-
-    def metadata
-      @variants.values.inject({}) do |metadata, variant|
-        metadata.merge(variant.metadata(self))
-      end
-    end
-  end
-
-  class Variant
-    attr_reader :key, :title, :value
-
-    def initialize(key, title, value)
-      @key, @title, @value = key, title, check_lambda_arity(value)
-    end
-
-    def metadata(option_set)
-      data = { key => value }
-      if value.is_a? Hash
-        value.each do |k, v|
-          sub_key = "%s_%s" % [key, k]
-          data[sub_key.to_sym] = v
-        end
-      end
-
-      data.each do |key, v|
-        data[key] = v.calculate(option_set) if v.is_a? CalculatedValue
-      end
-      data
-    end
-
-    def self.join(variants)
-      title, metadata = nil, {}
-      variants.each do |v|
-        title = [title, v.title].compact.join(' ')
-        metadata.merge!(v.metadata)
-      end
-      [title, metadata]
-    end
-
-    private
-
-      # Лямдда будет передаваться как блок в instance_eval, которому плохеет, если пришло что-то с нулевой
-      # arity. Поэтому для лямбд с нулевой arity делаем arity == 1
-      def check_lambda_arity(v)
-        if v.is_a?(Proc) && v.arity == 0
-          ->(_) { instance_exec(&v) }
-        else
-          v
-        end
-      end
-  end
-
-  class CalculatedValue
-    def initialize(&block)
-      @proc = block
-    end
-
-    def calculate(option_set)
-      @proc.call(option_set)
-    end
-  end
-
-  class Option
-    attr_reader :variants
-    def initialize(key, variants)
-      @variants =
-        if variants.is_a? Hash
-          variants.map { |title, value| Variant.new(key, title, value) }
-        else
-          # Array of arrays of two elements
-          variants.map { |v| Variant.new(key, *v) }
-        end
-    end
-
-    # Variants to apply at one level
-    def level_variants
-      variants
-    end
-
-    def next_variant
-      @current ||= 0
-      selected_variant = variants[@current]
-      @current += 1
-      if @current >= variants.length
-        @current = 0
-        @complete = true # all variants have been selected
+    def method_missing(method, *args, &block)
+      if metadata.keys.include?(method)
+        metadata[method]
+      else
+        super
       end
-      selected_variant
     end
-  end
 
-  class Diagonal < Option
-    def level_variants
-      [next_variant]
+    def respond_to_missing?(method, *)
+      metadata.keys.include?(method) or super
     end
-
-    def complete?
-      @complete
-    end
-  end
-
-  # RSpec helpers for spec builing
-  module RSpecInjections
-    def match_metadata?(metadata_key)
-      case metadata_key
-      when Hash
-        metadata_key.keys.all? { |k| metadata[k] == metadata_key[k] }
-      when Array
-        metadata_key.map { |key| metadata[key] }.none?(&:nil?)
-      else
-        metadata[metadata_key]
-      end
-    end
-  end
-end
+end

data/lib/lopata/scenario_builder.rb

@@ -0,0 +1,311 @@
+class Lopata::ScenarioBuilder
+  def self.define(title, metadata = nil, &block)
+    builder = new
+    builder.title(title)
+    builder.metadata(metadata) if metadata
+    builder.instance_exec &block
+    builder.build
+  end
+
+  # Do noting. Exclude defined scenario from suite.
+  def self.xdefine(*attrs)
+  end
+
+  def build
+    world = Lopata::Config.world
+    option_combinations.map do |option_set|
+      args = prepare_args(option_set)
+      raise "scenario required a name in first argument" unless args.first.is_a? String
+      scenario = Lopata::Scenario.new(*args)
+
+      steps.each do |step|
+        scenario.steps << step
+      end
+
+      scenario.steps << Lopata::Config.after_scenario if Lopata::Config.after_scenario
+
+      world.scenarios << scenario
+    end
+  end
+
+  def as(*args, &block)
+    @roles = args.flatten
+    @roles << CalculatedValue.new(&block) if block_given?
+    @role_options = nil
+  end
+
+  def role_options
+    @role_options ||= build_role_options
+  end
+
+  def metadata(hash)
+    raise 'metadata expected to be a Hash' unless hash.is_a?(Hash)
+    @common_metadata ||= {}
+    @common_metadata.merge! hash
+  end
+
+  def without_user
+    @without_user = true
+  end
+
+  def skip_when(&block)
+    @skip_when = block
+  end
+
+  def skip?(option_set)
+    @skip_when && @skip_when.call(option_set)
+  end
+
+  %i{setup action it teardown}.each do |name|
+    name_if = "%s_if" % name
+    name_unless = "%s_unless" % name
+    define_method name, ->(*args, &block) { add_step(name, *args, &block) }
+    define_method name_if, ->(condition, *args, &block) { add_step(name, *args, if_cond: condition, &block) }
+    define_method name_unless, ->(condition, *args, &block) { add_step(name, *args, unless_cond: condition, &block) }
+  end
+
+  def add_step(method_name, *args, if_cond: nil, unless_cond: nil, &block)
+    steps << Lopata::Step.new(method_name, *args) do
+      # will be called in context of scenario
+      next if if_cond && !match_metadata?(if_cond)
+      next if unless_cond && match_metadata?(unless_cond)
+
+      flat_args = args.flatten
+      flat_args = separate_args(flat_args) if method_name =~ /^(setup|action)/
+      converted_args = convert_args(*flat_args)
+      converted_args.shift if method_name =~ /^it$/
+      converted_args.each do |step|
+        if step.is_a?(String)
+          Lopata::SharedStep.find(step).steps.each do |shared_step|
+            instance_exec(&shared_step.block)
+          end
+        elsif step.is_a?(Proc)
+          instance_exec(&step)
+        end
+      end
+      # run_step method_name, *converted_args, &block
+      instance_exec(&block) if block
+    end
+  end
+
+  def steps
+    @steps ||= []
+  end
+
+  def cleanup(*args, &block)
+    add_step_as_is(:cleanup, *args, &block)
+  end
+
+  def add_step_as_is(method_name, *args, &block)
+    steps << Lopata::Step.new(method_name, *args) do
+      # do not convert args - symbols mean name of instance variable
+      # run_step method_name, *args, &block
+      instance_exec(&block) if block
+    end
+  end
+
+  def let(method_name, &block)
+    steps << Lopata::Step.new(nil) do
+      define_singleton_method method_name, &block
+    end
+  end
+
+  def build_role_options
+    return [] unless roles
+    [Diagonal.new(:as, roles.map { |r| [nil, r] })]
+  end
+
+  def roles
+    return false if @without_user
+    @roles ||= [Lopata::Config.default_role].compact
+  end
+
+  def title(value)
+    @title = value
+  end
+
+  def option(metadata_key, variants)
+    options << Option.new(metadata_key, variants)
+  end
+
+  def diagonal(metadata_key, variants)
+    diagonals << Diagonal.new(metadata_key, variants)
+  end
+
+  def options
+    @options ||= []
+  end
+
+  def diagonals
+    @diagonals ||= []
+  end
+
+  def option_combinations
+    combinations = combine([OptionSet.new], options + diagonals + role_options)
+    while !(diagonals + role_options).all?(&:complete?)
+      combinations << OptionSet.new(*(options + diagonals + role_options).map(&:next_variant))
+    end
+    combinations.reject { |option_set| skip?(option_set) }
+  end
+
+  def combine(source_combinations, rest_options)
+    # raise 'source_combinations cannot be empty' if source_combinations.blank?
+    return source_combinations if rest_options.empty?
+    combinations = []
+    current_option = rest_options.shift
+    source_combinations.each do |source_variants|
+      current_option.level_variants.each do |v|
+        combinations << (source_variants + OptionSet.new(v))
+      end
+    end
+    combine(combinations, rest_options)
+  end
+
+  def prepare_args(option_set, *args)
+    options_title, metadata = option_set.title, option_set.metadata
+    if args[0].is_a? String
+      args[0] = [@title, options_title, args[0]].compact.reject(&:empty?).join(' ')
+    else
+      args.unshift([@title, options_title].compact.reject(&:empty?).join(' '))
+    end
+
+    metadata.merge!(@common_metadata) if @common_metadata
+
+    if args.last.is_a? Hash
+      args.last.merge!(metadata)
+    else
+      args << metadata
+    end
+    args
+  end
+
+  # Набор вариантов, собранный для одного теста
+  class OptionSet
+    attr_reader :variants
+    def initialize(*variants)
+      @variants = {}
+      variants.compact.each { |v| self << v }
+    end
+
+    def +(other_set)
+      self.class.new(*@variants.values).tap do |sum|
+        other_set.each { |v| sum << v }
+      end
+    end
+
+    def <<(variant)
+      @variants[variant.key] = variant
+    end
+
+    def [](key)
+      @variants[key]
+    end
+
+    def each(&block)
+      @variants.values.each(&block)
+    end
+
+    def title
+      @variants.values.map(&:title).compact.join(' ')
+    end
+
+    def metadata
+      @variants.values.inject({}) do |metadata, variant|
+        metadata.merge(variant.metadata(self))
+      end
+    end
+  end
+
+  class Variant
+    attr_reader :key, :title, :value
+
+    def initialize(key, title, value)
+      @key, @title, @value = key, title, check_lambda_arity(value)
+    end
+
+    def metadata(option_set)
+      data = { key => value }
+      if value.is_a? Hash
+        value.each do |k, v|
+          sub_key = "%s_%s" % [key, k]
+          data[sub_key.to_sym] = v
+        end
+      end
+
+      data.each do |key, v|
+        data[key] = v.calculate(option_set) if v.is_a? CalculatedValue
+      end
+      data
+    end
+
+    def self.join(variants)
+      title, metadata = nil, {}
+      variants.each do |v|
+        title = [title, v.title].compact.join(' ')
+        metadata.merge!(v.metadata)
+      end
+      [title, metadata]
+    end
+
+    private
+
+      # Лямдда будет передаваться как блок в instance_eval, которому плохеет, если пришло что-то с нулевой
+      # arity. Поэтому для лямбд с нулевой arity делаем arity == 1
+      def check_lambda_arity(v)
+        if v.is_a?(Proc) && v.arity == 0
+          ->(_) { instance_exec(&v) }
+        else
+          v
+        end
+      end
+  end
+
+  class CalculatedValue
+    def initialize(&block)
+      @proc = block
+    end
+
+    def calculate(option_set)
+      @proc.call(option_set)
+    end
+  end
+
+  class Option
+    attr_reader :variants
+    def initialize(key, variants)
+      @variants =
+        if variants.is_a? Hash
+          variants.map { |title, value| Variant.new(key, title, value) }
+        else
+          # Array of arrays of two elements
+          variants.map { |v| Variant.new(key, *v) }
+        end
+    end
+
+    # Variants to apply at one level
+    def level_variants
+      variants
+    end
+
+    def next_variant
+      @current ||= 0
+      selected_variant = variants[@current]
+      @current += 1
+      if @current >= variants.length
+        @current = 0
+        @complete = true # all variants have been selected
+      end
+      selected_variant
+    end
+  end
+
+  class Diagonal < Option
+    def level_variants
+      [next_variant]
+    end
+
+    def complete?
+      @complete
+    end
+  end
+end

data/lib/lopata/shared_step.rb

@@ -0,0 +1,31 @@
+module Lopata
+  class SharedStep
+    attr_reader :block
+
+    class SharedStepNotFound < StandardError; end
+
+    def self.register(name, &block)
+      raise ArgumentError, "Comma is not allowed in shared step name: '%s'" % name if name =~ /,/
+      @shared_steps ||= {}
+      @shared_steps[name] = new(&block)
+    end
+
+    def self.find(name)
+      @shared_steps[name] or raise StandardError, "Shared step '%s' not found" % name
+    end
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def steps
+      @steps ||= build_steps
+    end
+
+    def build_steps
+      builder = Lopata::ScenarioBuilder.new
+      builder.instance_exec(&block)
+      builder.steps
+    end
+  end
+end

data/lib/lopata/step.rb

@@ -0,0 +1,42 @@
+module Lopata
+  class Step
+    attr_reader :block, :status, :exception
+
+    def initialize(method_name, *args, &block)
+      @method_name = method_name
+      @args = args
+      @status = :not_started
+      @block = block
+      @exception = nil
+    end
+
+    def run(scenario)
+      @status = :running
+      world.notify_observers(:step_started, self)
+      begin
+        scenario.instance_exec(&block)
+        @status = :passed
+      rescue Exception => e
+        @status = :failed
+        @exception = e
+      end
+      world.notify_observers(:step_finished, self)
+    end
+
+    def world
+      @world ||= Lopata::Config.world
+    end
+
+    def failed?
+      status == :failed
+    end
+
+    def passed?
+      status == :passed
+    end
+
+    def teardown?
+      %i{ teardown cleanup }.include?(@method_name)
+    end
+  end
+end

data/lib/lopata/version.rb

@@ -0,0 +1,5 @@
+module Lopata
+  module Version
+    STRING = '0.1.0'
+  end
+end

data/lib/lopata/world.rb

@@ -0,0 +1,49 @@
+class Lopata::World
+  attr_reader :scenarios, :observers
+
+  def initialize
+    @scenarios = []
+    @observers = []
+  end
+
+  # Loads scenarios for running in current session
+  #
+  # @param args [Array<String>] files to be load.
+  #   All files from default location to be loaded if empty.
+  def load_scenarios(*args)
+    if args.empty?
+      load_all_scenarios
+    else
+      args.each do |file|
+        load File.expand_path(file)
+      end
+    end
+  end
+
+  # Loads all scenarios from predefined paths
+  def load_all_scenarios
+    Dir["scenarios/**/*.rb"].each { |f| load File.expand_path(f) }
+  end
+
+  def load_shared_steps
+    Dir["shared_steps/**/*rb"].each { |f| load File.expand_path(f) }
+  end
+
+  # Called at the end of test running.
+  #
+  # Notifies observers about testing finish
+  def finish
+    notify_observers(:finished, self)
+  end
+
+  def notify_observers(event, context)
+    @observers.each do |observer|
+      observer.send event, context
+    end
+  end
+
+  # Define observers based on configuration
+  def setup_observers
+    @observers = [Lopata::Observers::ConsoleOutputObserver.new]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lopata
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.1.0
 platform: ruby
 authors:
 - Alexey Volochnev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-06 00:00:00.000000000 Z
+date: 2020-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -30,15 +30,57 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Functional acceptance tesging with rspec
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Functional acceptance tesging
 email: alexey.volochnev@gmail.com
 executables:
 - lopata
@@ -56,14 +98,22 @@ files:
 - lib/lopata/generators/templates/Lopatafile
 - lib/lopata/generators/templates/config/environments/qa.yml
 - lib/lopata/generators/templates/config/initializers/capybara.rb
+- lib/lopata/generators/templates/spec/spec_helper.rb
 - lib/lopata/id.rb
+- lib/lopata/observers.rb
+- lib/lopata/observers/base_observer.rb
+- lib/lopata/observers/console_output_observer.rb
 - lib/lopata/rspec/ar_dsl.rb
 - lib/lopata/rspec/dsl.rb
 - lib/lopata/rspec/formatter.rb
 - lib/lopata/rspec/role.rb
-- lib/lopata/rspec/version.rb
 - lib/lopata/runner.rb
 - lib/lopata/scenario.rb
+- lib/lopata/scenario_builder.rb
+- lib/lopata/shared_step.rb
+- lib/lopata/step.rb
+- lib/lopata/version.rb
+- lib/lopata/world.rb
 homepage: https://github.com/avolochnev/lopata
 licenses:
 - MIT
@@ -76,7 +126,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -86,5 +136,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: lopata-0.0.16
+summary: lopata-0.1.0
 test_files: []

data/lib/lopata/rspec/version.rb

@@ -1,7 +0,0 @@
-module Lopata
-  module RSpec
-    module Version
-      STRING = '0.0.16'
-    end
-  end
-end