lopata 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9233d9fba2a55749f02037d5ca106c0cb9249debda448aac58ccc2cc724a378e
-  data.tar.gz: 65ea743e92f5084b6f04b52595296cb80a3d4540f4cb8ba8bc2c774cbc448aaf
+  metadata.gz: 996fe5f1c16b6fed5daadff4ce365a778c2f09d79562c221e497c541541e9012
+  data.tar.gz: 7200a98d6bead7fb3baed82bbdffbf1c6aca805d999a563f3ada78026344dfed
 SHA512:
-  metadata.gz: a706fde4a5acc83b27400ce50c19137b7fd9f296bfb2ac4baeec55e50e5fe48b4bf6e90110611f4f69cd2dc9571a15d1de34e54e8bec094f0c2c2d5cc5ca1a87
-  data.tar.gz: 2d0764e801260489815f30b8572ffdff7bdf6572fc64b55d0e53c091f8f125925374ae9cf706b1fe0bc956a6d56ef23b6dd1bd767b7ce13de550b4878dc86f4f
+  metadata.gz: 037ccc6d687292186b752de6924a2f3373d0934569f9e2d01567cac1a4607aa33ce70f53473ad0d737d07cdb1da231bb8b526f6c24f8c2e73d494978dfc94179
+  data.tar.gz: 7c90f679400d64d7ab676807cea167947cee47114cf9ea8daed84c517888bf5e7e64b475c1841f9e6cb886cf08184ca3acedaf6dc5af68a3518e74e4130f91b7

data/lib/lopata/active_record.rb

@@ -0,0 +1,36 @@
+module Lopata
+  module ActiveRecord
+    # To be included in Lopata::Scenario
+    module Methods
+      def cleanup(*objects)
+        return if Lopata::Config.ops[:keep]
+        objects.flatten.compact.each do |o|
+          begin
+            o.reload.destroy!
+          rescue ::ActiveRecord::RecordNotFound
+            # Already destroyed
+          end
+        end
+      end
+
+      def reload(*objects)
+        objects.flatten.each(&:reload)
+      end
+    end
+
+    # To be included in Lopata::ScenarioBuilder
+    module DSL
+      def cleanup(*vars, &block)
+        unless vars.empty?
+          teardown do
+            cleanup vars.map { |v| instance_variable_get "@#{v}" }
+          end
+        end
+        teardown &block if block_given?
+      end
+    end
+  end
+end
+
+Lopata::Scenario.include Lopata::ActiveRecord::Methods
+Lopata::ScenarioBuilder.include Lopata::ActiveRecord::DSL

data/lib/lopata/condition.rb

@@ -5,8 +5,6 @@ module Lopata
       @condition, @positive = condition, positive
     end
 
-    EMPTY = new({})
-
     alias positive? positive
 
     def match?(scenario)

data/lib/lopata/config.rb

@@ -2,8 +2,8 @@ module Lopata
   module Config
     extend self
 
-    attr_accessor :build_number, :lopata_host, :lopata_code, :only_roles, :role_descriptions, :after_as,
-                  :default_role, :ops, :after_scenario
+    attr_accessor :build_number, :lopata_host, :lopata_code, :only_roles, :role_descriptions,
+                  :default_role, :ops
 
     def init(env)
       require 'yaml'
@@ -40,34 +40,15 @@ module Lopata
       init_rspec_filters
     end
 
-    def init_active_record
-      require 'lopata/rspec/ar_dsl'
-      ::RSpec.configure do |c|
-        c.include Lopata::RSpec::AR::DSL
-      end
-    end
-
     def init_lopata_logging(build)
       self.build_number = build
       require 'lopata/observers/web_logger'
       add_observer Lopata::Observers::WebLogger.new
     end
 
-    def init_rerun
-      ::RSpec.configure do |c|
-        c.inclusion_filter = { full_description: build_rerun_filter_proc }
-      end
-    end
-
     def init_rspec_filters
       filters = {}
       filters[:focus] = true if ops[:focus]
-      if ops[:rerun]
-        filters[:full_description] = build_rerun_filter_proc
-      end
-      if ops[:text]
-        filters[:full_description] = ->(desc) { desc.include?(ops[:text]) }
-      end
       unless filters.blank?
         ::RSpec.configure do |c|
           c.inclusion_filter = filters
@@ -75,17 +56,28 @@ module Lopata
       end
     end
 
-    def build_rerun_filter_proc
-      to_rerun = Lopata::Client.new(Lopata::Config.build_number).to_rerun
-      Proc.new do |desc|
-        to_rerun.include?(desc)
-      end
-    end
-
     def before_start(&block)
       @before_start = block
     end
 
+    def before_scenario(*steps, &block)
+      before_scenario_steps.append(*steps) unless steps.empty?
+      before_scenario_steps.append(block) if block_given?
+    end
+
+    def before_scenario_steps
+      @before_scenario_steps ||= []
+    end
+
+    def after_scenario(*steps, &block)
+      after_scenario_steps.append(*steps) unless steps.empty?
+      after_scenario_steps.append(block) if block_given?
+    end
+
+    def after_scenario_steps
+      @after_scenario_steps ||= []
+    end
+
     def initialize_test
       @before_start.call if @before_start
     end
@@ -94,6 +86,10 @@ module Lopata
       @world ||= Lopata::World.new
     end
 
+    def filters
+      @filters ||= []
+    end
+
     def add_observer(observer)
       world.observers << observer
     end

data/lib/lopata/factory_bot.rb

@@ -0,0 +1,36 @@
+require_relative 'active_record'
+
+module Lopata
+  module FactoryBot
+    # To be included in Lopata::Scenario
+    module Methods
+      def create(*params)
+        cleanup_later ::FactoryBot.create(*params)
+      end
+
+      def find_created(cls, params)
+        cleanup_later cls.where(params).take
+      end
+
+      def cleanup_later(object)
+        return nil unless object
+        @created_objects ||= []
+        @created_objects << object
+        object
+      end
+    end
+
+    # To be included in Lopata::ScenarioBuilder
+    module DSL
+    end
+  end
+end
+
+Lopata::Scenario.include Lopata::FactoryBot::Methods
+Lopata::ScenarioBuilder.include Lopata::FactoryBot::DSL
+
+Lopata.configure do |c|
+  c.after_scenario { cleanup @created_objects }
+end
+
+::FactoryBot.find_definitions unless Lopata::Config.readonly

data/lib/lopata/observers/backtrace_formatter.rb

@@ -0,0 +1,89 @@
+module Lopata
+  module Observers
+    # Based on RSpec::Core::BacktraceFormatter
+    class BacktraceFormatter
+      attr_accessor :exclusion_patterns, :inclusion_patterns
+
+      def initialize
+        patterns = %w[ /lib\d*/ruby/ bin/ exe/lopata /lib/bundler/ /exe/bundle: ]
+        patterns.map! { |s| Regexp.new(s.gsub("/", File::SEPARATOR)) }
+
+        @exclusion_patterns = [Regexp.union(*patterns)]
+        @inclusion_patterns = []
+
+        inclusion_patterns << Regexp.new(Dir.getwd)
+      end
+
+      def format(backtrace)
+        return [] unless backtrace
+        return backtrace if backtrace.empty?
+
+        backtrace.map { |l| backtrace_line(l) }.compact.
+          tap do |filtered|
+            if filtered.empty?
+              filtered.concat backtrace
+              filtered << ""
+              filtered << "  Showing full backtrace because every line was filtered out."
+            end
+          end
+      end
+
+      def error_message(exception, include_backtrace: false)
+        backtrace = format(exception.backtrace)
+        source_line = extract_source_line(backtrace.first)
+        msg = ''
+        msg << "\n#{source_line}\n" if source_line
+        msg << "#{exception.class.name}: " unless exception.class.name =~ /RSpec/
+        msg << exception.message if exception.message
+        msg << "\n#{backtrace.join("\n")}\n" if include_backtrace
+        msg
+      end
+
+      def extract_source_line(backtrace_line)
+        file_and_line_number = backtrace_line.match(/(.+?):(\d+)(|:\d+)/)
+        return nil unless file_and_line_number
+        file_path, line_number = file_and_line_number[1..2]
+        return nil unless File.exist?(file_path)
+        lines = File.read(file_path).split("\n")
+        lines[line_number.to_i - 1]
+      end
+
+      def backtrace_line(line)
+        relative_path(line) unless exclude?(line)
+      end
+
+      def exclude?(line)
+        matches?(exclusion_patterns, line) && !matches?(inclusion_patterns, line)
+      end
+
+      private
+
+      def matches?(patterns, line)
+        patterns.any? { |p| line =~ p }
+      end
+
+      # Matches strings either at the beginning of the input or prefixed with a
+      # whitespace, containing the current path, either postfixed with the
+      # separator, or at the end of the string. Match groups are the character
+      # before and the character after the string if any.
+      #
+      # http://rubular.com/r/fT0gmX6VJX
+      # http://rubular.com/r/duOrD4i3wb
+      # http://rubular.com/r/sbAMHFrOx1
+      def relative_path_regex
+        @relative_path_regex ||= /(\A|\s)#{File.expand_path('.')}(#{File::SEPARATOR}|\s|\Z)/
+      end
+
+      # @param line [String] current code line
+      # @return [String] relative path to line
+      def relative_path(line)
+        line = line.sub(relative_path_regex, "\\1.\\2".freeze)
+        line = line.sub(/\A([^:]+:\d+)$/, '\\1'.freeze)
+        return nil if line == '-e:1'.freeze
+        line
+      rescue SecurityError
+        nil
+      end
+    end
+  end
+end

data/lib/lopata/observers/console_output_observer.rb

@@ -1,3 +1,5 @@
+require_relative 'backtrace_formatter'
+
 module Lopata
   module Observers
     class ConsoleOutputObserver < BaseObserver
@@ -11,24 +13,14 @@ module Lopata
         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)
+        return unless scenario.failed?
 
-        @failed_steps.each do |step|
-          if step.exception
-            puts step.exception.message
-            puts step.exception.backtrace.join("\n")
-            puts
-          end
+        scenario.steps_in_running_order.each do |step|
+          puts colored("  #{status_marker(step.status)} #{step.title}", step.status)
+          puts indent(4, backtrace_formatter.error_message(step.exception, include_backtrace: true)) if step.failed?
         end
       end
 
@@ -38,25 +30,48 @@ module Lopata
         case status
         when :failed then red(text)
         when :passed then green(text)
+        when :skipped then cyan(text)
+        when :pending then yellow(text)
         else text
         end
       end
 
-      def red(text)
-        wrap(text, 31)
+      {
+        red: 31,
+        green: 32,
+        cyan: 36,
+        yellow: 33,
+        bold: 1,
+      }.each do |color, code|
+        define_method(color) do |text|
+          wrap(text, code)
+        end
+      end
+
+      def wrap(text, code)
+        "\e[#{code}m#{text}\e[0m"
       end
 
-      def green(text)
-        wrap(text, 32)
+      def backtrace_formatter
+        @backtrace_formatter ||= Lopata::Observers::BacktraceFormatter.new
       end
 
-      def bold(text)
-        wrap(text, 1)
+      def status_marker(status)
+        case status
+        when :failed then "[!]"
+        when :skipped then "[-]"
+        when :pending then "[?]"
+        else "[+]"
+        end
       end
 
-      def wrap(text, code)
-        "\e[#{code}m#{text}\e[0m"
+      # Adds indent to text
+      # @param cols [Number] number of spaces to be added
+      # @param text [String] text to add indent
+      # @return [String] text with indent
+      def indent(cols, text)
+        text.split("\n").map { |line| " " * cols + line }.join("\n")
       end
     end
   end
-end
+end

data/lib/lopata/observers/web_logger.rb

@@ -1,5 +1,6 @@
 require 'httparty'
 require 'json'
+require_relative 'backtrace_formatter'
 
 module Lopata
   module Observers
@@ -11,46 +12,20 @@ module Lopata
       end
 
       def scenario_finished(scenario)
-        if scenario.failed?
-          backtrace = backtrace_for(scenario)
-          @client.add_attempt(scenario, Lopata::FAILED, error_message_for(scenario), backtrace)
-        else
-          @client.add_attempt(scenario, Lopata::PASSED)
-        end
+        @client.add_attempt(scenario)
       end
 
       # def example_pending(notification)
       #   example = notification.example
       #   @client.add_attempt(example, Lopata::PENDING, example.execution_result.pending_message)
       # end
-
-      private
-
-      def error_message_for(scenario)
-        exception = scenario.steps.map(&:exception).compact.last
-        msg = ''
-        if exception
-          msg << "#{exception.class.name}: " unless exception.class.name =~ /RSpec/
-          msg << "#{exception.message.to_s}" if exception.message
-        end
-        (msg.length == 0) ? 'Empty message' : msg
-      end
-
-      def backtrace_for(scenario)
-        exception = scenario.steps.map(&:exception).compact.last
-        msg = ''
-        if exception
-          msg = exception.backtrace.join("\n")
-          msg << "\n"
-        end
-        msg
-      end
     end
   end
 
   PASSED = 0
   FAILED = 1
   PENDING = 2
+  SKIPPED = 5
 
   class Client
     include HTTParty
@@ -66,15 +41,24 @@ module Lopata
       @launch_id = JSON.parse(post("/projects/#{project_code}/builds/#{build_number}/launches.json", body: {total: count}).body)['id']
     end
 
-    def add_attempt(scenario, status, msg = nil, backtrace = nil)
+    def add_attempt(scenario)
+      status = scenario.failed? ? Lopata::FAILED : Lopata::PASSED
+      steps = scenario.steps_in_running_order.map { |s| step_hash(s) }
+      request = { status: status, steps: steps }
       test = test_id(scenario)
-      request = { status: status}
-      request[:message] = msg if msg
-      request[:backtrace] = backtrace if backtrace
       post("/tests/#{test}/attempts.json", body: request)
       inc_finished
     end
 
+    def step_hash(step)
+      hash = { status: step.status, title: step.title }
+      if step.failed?
+        hash[:message] = error_message_for(step)
+        hash[:backtrace] = backtrace_for(step)
+      end
+      hash
+    end
+
     def test_id(scenario)
       request = {
         test: {
@@ -125,5 +109,26 @@ module Lopata
     def project_code
       Lopata::Config.lopata_code
     end
+
+    def error_message_for(step)
+      if step.exception
+        backtrace_formatter.error_message(step.exception)
+      else
+        'Empty error message'
+      end
+    end
+
+    def backtrace_for(step)
+      msg = ''
+      if step.exception
+        msg = backtrace_formatter.format(step.exception.backtrace).join("\n")
+        msg << "\n"
+      end
+      msg
+    end
+
+    def backtrace_formatter
+      @backtrace_formatter ||= Lopata::Observers::BacktraceFormatter.new
+    end
   end
 end

data/lib/lopata/rspec/dsl.rb

@@ -11,7 +11,7 @@ module Lopata
             if context.is_a?(Proc)
               action(&context)
             else
-              include_context context
+              verify context
             end
           end
           before(:all, &block) if block_given?

data/lib/lopata/rspec/role.rb

@@ -20,7 +20,6 @@ module Lopata::RSpec::Role
       else
         Lopata::RSpec::Role.filter_roles(*names).each do |name|
           example_group_class = describe role_description(name), :current_role => name do
-            instance_exec &Lopata::Config.after_as if Lopata::Config.after_as
             define_method :current_role do
               name
             end

data/lib/lopata/runner.rb

@@ -40,15 +40,25 @@ module Lopata
       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
+        add_text_filter(options[:text]) if options[:text]
+        add_rerun_filter if options[:rerun]
+      end
+
+      def add_text_filter(text)
+        Lopata::Config.filters << -> (scenario) { scenario.title.include?(text) }
+      end
+
+      def add_rerun_filter
+        to_rerun = Lopata::Client.new(Lopata::Config.build_number).to_rerun
+        puts to_rerun
+        Lopata::Config.filters << -> (scenario) { to_rerun.include?(scenario.title) }
       end
     end
   end

data/lib/lopata/scenario.rb

@@ -3,55 +3,83 @@ require 'rspec/expectations'
 class Lopata::Scenario
   include RSpec::Matchers
 
-  attr_reader :title, :metadata, :steps, :status
+  attr_reader :execution
 
-  def initialize(title, options_title, metadata = {})
-    @title = [title, options_title].compact.reject(&:empty?).join(' ')
-    @metadata = metadata
-    @steps = []
-    @status = :not_runned
+  def initialize(execution)
+    @execution = execution
   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)
+  # Marks current step as pending
+  def pending(message = nil)
+    execution.current_step.pending!(message)
   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?)
+  def metadata
+    execution.metadata
+  end
+
+  private
+
+  def method_missing(method, *args, &block)
+    if metadata.keys.include?(method)
+      metadata[method]
     else
-      metadata[metadata_key]
+      super
     end
   end
 
-  def world
-    @world ||= Lopata::Config.world
+  def respond_to_missing?(method, *)
+    metadata.keys.include?(method) or super
   end
 
-  def failed?
-    status == :failed
-  end
+  class Execution
+    attr_reader :scenario, :status, :steps, :title, :current_step
 
-  private
+    def initialize(title, options_title, metadata = {})
+      @title = [title, options_title].compact.reject(&:empty?).join(' ')
+      @metadata = metadata
+      @status = :not_runned
+      @steps = []
+      @scenario = Lopata::Scenario.new(self)
+    end
 
-    def method_missing(method, *args, &block)
-      if metadata.keys.include?(method)
-        metadata[method]
-      else
-        super
-      end
+    def run
+      @status = :running
+      world.notify_observers(:scenario_started, self)
+      steps_in_running_order.each(&method(:run_step))
+      @status = steps.any?(&:failed?) ? :failed : :passed
+      world.notify_observers(:scenario_finished, self)
+    end
+
+    def run_step(step)
+      return if step.skipped?
+      @current_step = step
+      step.run(scenario)
+      skip_rest if step.failed? && step.skip_rest_on_failure?
     end
 
-    def respond_to_missing?(method, *)
-      metadata.keys.include?(method) or super
+    def world
+      @world ||= Lopata::Config.world
     end
-end
+
+    def failed?
+      status == :failed
+    end
+
+    def steps_in_running_order
+      steps.reject(&:teardown_group?) + steps.select(&:teardown_group?)
+    end
+
+    def skip_rest
+      steps.select { |s| s.status == :not_runned && !s.teardown? }.each(&:skip!)
+    end
+
+    def metadata
+      if current_step
+        @metadata.merge(current_step.metadata)
+      else
+        @metadata
+      end
+    end
+  end
+end

data/lib/lopata/scenario_builder.rb

@@ -1,5 +1,6 @@
 class Lopata::ScenarioBuilder
   attr_reader :title, :common_metadata
+  attr_accessor :shared_step, :group
 
   def self.define(title, metadata = {}, &block)
     builder = new(title, metadata)
@@ -12,18 +13,18 @@ class Lopata::ScenarioBuilder
   end
 
   def build
+    filters = Lopata::Config.filters
     option_combinations.each do |option_set|
       metadata = common_metadata.merge(option_set.metadata)
-      scenario = Lopata::Scenario.new(title, option_set.title, metadata)
+      scenario = Lopata::Scenario::Execution.new(title, option_set.title, metadata)
 
-      steps.each do |step|
-        next if step.condition && !step.condition.match?(scenario)
-        step.pre_steps(scenario).each { |s| scenario.steps << s }
-        scenario.steps << step
+      unless filters.empty?
+        next unless filters.all? { |f| f[scenario] }
       end
 
-      if Lopata::Config.after_scenario
-        scenario.steps << Lopata::Step.new(:after_scenario, &Lopata::Config.after_scenario)
+      steps_with_hooks.each do |step|
+        next if step.condition && !step.condition.match?(scenario)
+        step.execution_steps(scenario).each { |s| scenario.steps << s }
       end
 
       world.scenarios << scenario
@@ -58,28 +59,49 @@ class Lopata::ScenarioBuilder
     @skip_when && @skip_when.call(option_set)
   end
 
-  %i{ setup action it teardown }.each do |name|
+  %i{ setup action it teardown verify context }.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, condition: Lopata::Condition.new(condition), &block) }
-    define_method name_unless, ->(condition, *args, &block) { add_step(name, *args, condition: Lopata::Condition.new(condition, positive: false), &block) }
+    define_method name, ->(*args, **metadata, &block) { add_step(name, *args, metadata: metadata, &block) }
+    define_method name_if, ->(condition, *args, **metadata, &block) {
+      add_step(name, *args, metadata: metadata, condition: Lopata::Condition.new(condition), &block)
+    }
+    define_method name_unless, ->(condition, *args, **metadata, &block) {
+      add_step(name, *args, condition: Lopata::Condition.new(condition, positive: false), metadata: metadata, &block)
+    }
   end
 
-  def add_step(method_name, *args, condition: nil, &block)
+  def add_step(method_name, *args, condition: nil, metadata: {}, &block)
     step_class =
-      if method_name =~ /^(setup|action|teardown)/
-        Lopata::ActionStep
-      else
-        Lopata::Step
+      case method_name
+      when /^(setup|action|teardown|verify)/ then Lopata::ActionStep
+      when /^(context)/ then Lopata::GroupStep
+      else Lopata::Step
       end
-    steps << step_class.new(method_name, *args, condition: condition, &block)
+    step = step_class.new(method_name, *args, condition: condition, shared_step: shared_step, group: group, &block)
+    step.metadata = metadata
+    steps << step
   end
 
   def steps
     @steps ||= []
   end
 
+  def steps_with_hooks
+    s = []
+    unless Lopata::Config.before_scenario_steps.empty?
+      s << Lopata::ActionStep.new(:setup, *Lopata::Config.before_scenario_steps)
+    end
+
+    s += steps
+
+    unless Lopata::Config.after_scenario_steps.empty?
+      s << Lopata::ActionStep.new(:teardown, *Lopata::Config.after_scenario_steps)
+    end
+
+    s
+  end
+
   def cleanup(*args, &block)
     add_step_as_is(:cleanup, *args, &block)
   end
@@ -187,10 +209,10 @@ class Lopata::ScenarioBuilder
   end
 
   class Variant
-    attr_reader :key, :title, :value
+    attr_reader :key, :title, :value, :option
 
-    def initialize(key, title, value)
-      @key, @title, @value = key, title, check_lambda_arity(value)
+    def initialize(option, key, title, value)
+      @option, @key, @title, @value = option, key, title, check_lambda_arity(value)
     end
 
     def metadata(option_set)
@@ -202,6 +224,10 @@ class Lopata::ScenarioBuilder
         end
       end
 
+      option.available_metadata_keys.each do |key|
+        data[key] = nil unless data.has_key?(key)
+      end
+
       data.each do |key, v|
         data[key] = v.calculate(option_set) if v.is_a? CalculatedValue
       end
@@ -241,14 +267,15 @@ class Lopata::ScenarioBuilder
   end
 
   class Option
-    attr_reader :variants
+    attr_reader :variants, :key
     def initialize(key, variants)
+      @key = key
       @variants =
         if variants.is_a? Hash
-          variants.map { |title, value| Variant.new(key, title, value) }
+          variants.map { |title, value| Variant.new(self, key, title, value) }
         else
           # Array of arrays of two elements
-          variants.map { |v| Variant.new(key, *v) }
+          variants.map { |v| Variant.new(self, key, *v) }
         end
     end
 
@@ -267,6 +294,11 @@ class Lopata::ScenarioBuilder
       end
       selected_variant
     end
+
+    def available_metadata_keys
+      @available_metadata_keys ||= variants
+        .map(&:value).select { |v| v.is_a?(Hash) }.flat_map(&:keys).map { |k| "#{key}_#{k}".to_sym  }.uniq
+    end
   end
 
   class Diagonal < Option

data/lib/lopata/shared_step.rb

@@ -2,16 +2,15 @@ module Lopata
   class SharedStep
     attr_reader :name, :block
 
-    class SharedStepNotFound < StandardError; end
+    class NotFound < 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(name, &block)
+      registry[name] = new(name, &block)
     end
 
     def self.find(name)
-      @shared_steps[name] or raise StandardError, "Shared step '%s' not found" % name
+      registry[name] or raise NotFound, "Shared step '%s' not found" % name
     end
 
     def initialize(name, &block)
@@ -24,8 +23,15 @@ module Lopata
 
     def build_steps
       builder = Lopata::ScenarioBuilder.new(name)
+      builder.shared_step = self
       builder.instance_exec(&block)
       builder.steps
     end
+
+    private
+
+    def self.registry
+      @shared_steps ||= {}
+    end
   end
 end

data/lib/lopata/step.rb

@@ -1,14 +1,118 @@
 module Lopata
   class Step
-    attr_reader :block, :status, :exception, :args, :condition
+    attr_reader :block, :args, :condition, :method_name, :shared_step, :group
+    # metadata overrien by the step.
+    attr_accessor :metadata
 
-    def initialize(method_name, *args, condition: nil, &block)
+    def initialize(method_name, *args, condition: nil, shared_step: nil, group: nil, &block)
       @method_name = method_name
       @args = args
-      @status = :not_started
       @block = block
+      @shared_step = shared_step
+      @condition = condition
+      @group = group
+      initialized! if defined? initialized!
+    end
+
+    def title
+      base_title = args.first
+      base_title ||= shared_step && "#{method_name.capitalize} #{shared_step.name}" || "Untitled #{method_name}"
+      if group
+        "#{group.title}: #{base_title}"
+      else
+        base_title
+      end
+    end
+
+    def execution_steps(scenario, groups: [])
+      return [] if condition && !condition.match?(scenario)
+      return [] unless block
+      [StepExecution.new(self, groups, &block)]
+    end
+  end
+
+  # Used for action, setup, teardown
+  class ActionStep < Step
+    def execution_steps(scenario, groups: [])
+      steps = []
+      return steps if condition && !condition.match?(scenario)
+      convert_args(scenario).each do |step|
+        if step.is_a?(String)
+          Lopata::SharedStep.find(step).steps.each do |shared_step|
+            next if shared_step.condition && !shared_step.condition.match?(scenario)
+            steps += shared_step.execution_steps(scenario, groups: groups)
+          end
+        elsif step.is_a?(Proc)
+          steps << StepExecution.new(self, groups, &step)
+        end
+      end
+      steps << StepExecution.new(self, groups, &block) if block
+      steps.reject { |s| !s.block }
+    end
+
+    def separate_args(args)
+      args.map { |a| a.is_a?(String) && a =~ /,/ ? a.split(',').map(&:strip) : a }.flatten
+    end
+
+    def convert_args(scenario)
+      flat_args = separate_args(args.flatten)
+      flat_args.map do |arg|
+        case arg
+          # trait symbols as link to metadata.
+          when Symbol then scenario.metadata[arg]
+        else
+          arg
+        end
+      end.flatten
+    end
+
+    def title
+      if group
+        "%s: %s" % [group.title, method_name]
+      else
+        shared_step && "#{method_name.capitalize} #{shared_step.name}" || "Untitled #{method_name}"
+      end
+    end
+  end
+
+  # Used for context
+  class GroupStep < Step
+
+    def execution_steps(scenario, groups: [])
+      steps = []
+      return steps if condition && !condition.match?(scenario)
+      @steps.each do |step|
+        steps += step.execution_steps(scenario, groups: groups + [self])
+      end
+      steps.reject! { |s| !s.block }
+      steps.reject { |s| s.teardown_group?(self) } + steps.select { |s| s.teardown_group?(self) }
+    end
+
+    private
+
+    # Group step's block is a block in context of builder, not scenario. So hide the @block to not be used in scenario.
+    def initialized!
+      builder = Lopata::ScenarioBuilder.new(title)
+      builder.group = self
+      builder.instance_exec(&@block)
+      @steps = builder.steps
+      @block = nil
+    end
+  end
+
+  class StepExecution
+    attr_reader :step, :status, :exception, :block, :pending_message, :groups
+    extend Forwardable
+    def_delegators :step, :title, :method_name
+
+    class PendingStepFixedError < StandardError; end
+
+    def initialize(step, groups, &block)
+      @step = step
+      @status = :not_runned
       @exception = nil
-      @condition = condition || Lopata::Condition::EMPTY
+      @block = block
+      @groups = groups
     end
 
     def run(scenario)
@@ -16,16 +120,22 @@ module Lopata
       world.notify_observers(:step_started, self)
       begin
         run_step(scenario)
-        @status = :passed
+        if pending?
+          @status = :failed
+          raise PendingStepFixedError, 'Expected step to fail since it is pending, but it passed.'
+        else
+          @status = :passed
+        end
       rescue Exception => e
-        @status = :failed
+        @status = :failed unless pending?
         @exception = e
       end
       world.notify_observers(:step_finished, self)
     end
 
     def run_step(scenario)
-      scenario.instance_exec(&block) if block
+      return unless block
+      scenario.instance_exec(&block)
     end
 
     def world
@@ -40,47 +150,38 @@ module Lopata
       status == :passed
     end
 
-    def teardown?
-      %i{ teardown cleanup }.include?(@method_name)
+    def skipped?
+      status == :skipped
     end
 
-    def pre_steps(scenario)
-      []
+    def skip!
+      @status = :skipped
     end
-  end
 
-  # Used for action, setup, teardown
-  class ActionStep < Step
-    def pre_steps(scenario)
-      steps = []
-      convert_args(scenario).each do |step|
-        if step.is_a?(String)
-          Lopata::SharedStep.find(step).steps.each do |shared_step|
-            steps += shared_step.pre_steps(scenario)
-            steps << shared_step
-          end
-        elsif step.is_a?(Proc)
-          steps << Lopata::Step.new(method_name, &step)
-        end
-      end
-      steps
+    def pending?
+      status == :pending
     end
 
-    def separate_args(args)
-      args.map { |a| a.is_a?(String) && a =~ /,/ ? a.split(',').map(&:strip) : a }.flatten
+    def pending!(message = nil)
+      @status = :pending
+      @pending_message = message
     end
 
-    def convert_args(scenario)
-      flat_args = separate_args(args.flatten)
-      flat_args.map do |arg|
-        case arg
-          # trait symbols as link to metadata.
-          when Symbol then scenario.metadata[arg]
-        else
-          arg
-        end
-      end.flatten
+    def teardown?
+      %i{ teardown cleanup }.include?(method_name)
     end
 
+    def teardown_group?(group = nil)
+      teardown? && self.groups.last == group
+    end
+
+    def skip_rest_on_failure?
+      %i{ setup action }.include?(method_name)
+    end
+
+    # Step metadata is a combination of metadata given for step and all contexts (groups) the step included
+    def metadata
+      ([step] + groups).compact.inject({}) { |merged, part| merged.merge(part.metadata) }
+    end
   end
-end
+end

data/lib/lopata/version.rb

@@ -1,5 +1,5 @@
 module Lopata
   module Version
-    STRING = '0.1.1'
+    STRING = '0.1.2'
   end
 end

data/lib/lopata.rb

@@ -17,4 +17,8 @@ module Lopata
   def self.shared_step(name, &block)
     Lopata::SharedStep.register(name, &block)
   end
+
+  def self.configure(&block)
+    yield Lopata::Config
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lopata
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Alexey Volochnev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-14 00:00:00.000000000 Z
+date: 2020-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -80,7 +80,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: Functional acceptance tesging
+description: Functional acceptance testing
 email: alexey.volochnev@gmail.com
 executables:
 - lopata
@@ -90,8 +90,10 @@ files:
 - README.md
 - exe/lopata
 - lib/lopata.rb
+- lib/lopata/active_record.rb
 - lib/lopata/condition.rb
 - lib/lopata/config.rb
+- lib/lopata/factory_bot.rb
 - lib/lopata/generators/app.rb
 - lib/lopata/generators/templates/.rspec
 - lib/lopata/generators/templates/Gemfile
@@ -102,10 +104,10 @@ files:
 - lib/lopata/id.rb
 - lib/lopata/loader.rb
 - lib/lopata/observers.rb
+- lib/lopata/observers/backtrace_formatter.rb
 - lib/lopata/observers/base_observer.rb
 - lib/lopata/observers/console_output_observer.rb
 - lib/lopata/observers/web_logger.rb
-- lib/lopata/rspec/ar_dsl.rb
 - lib/lopata/rspec/dsl.rb
 - lib/lopata/rspec/role.rb
 - lib/lopata/runner.rb
@@ -137,5 +139,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: lopata-0.1.1
+summary: lopata-0.1.2
 test_files: []

data/lib/lopata/rspec/ar_dsl.rb

@@ -1,38 +0,0 @@
-module Lopata
-  module RSpec
-    module AR
-      module DSL
-        def self.included(base)
-          base.extend(ClassMethods)
-        end
-
-        def cleanup(*objects)
-          return if Lopata::Config.ops[:keep]
-          objects.flatten.compact.each do |o|
-            begin
-              o.reload.destroy!
-            rescue ActiveRecord::RecordNotFound
-              # Already destroyed
-            end
-          end
-        end
-
-        def reload(*objects)
-          objects.flatten.each(&:reload)
-        end
-
-
-        module ClassMethods
-          def cleanup(*vars, &block)
-            unless vars.empty?
-              teardown do
-                cleanup vars.map { |v| instance_variable_get "@#{v}" }
-              end
-            end
-            teardown &block if block_given?
-          end
-        end
-      end
-    end
-  end
-end