lib/lopata/scenario_builder.rb in lopata-0.1.5 vs lib/lopata/scenario_builder.rb in lopata-0.1.6

@@ -1,21 +1,23 @@
 class Lopata::ScenarioBuilder
-  attr_reader :title, :common_metadata
+  attr_reader :title, :common_metadata, :options, :diagonals
   attr_accessor :shared_step, :group
 
   def self.define(title, metadata = {}, &block)
     builder = new(title, metadata)
     builder.instance_exec &block
     builder.build
   end
 
   def initialize(title, metadata = {})
     @title, @common_metadata = title, metadata
+    @diagonals = []
+    @options = []
   end
 
   def build
-    filters = Lopata::Config.filters
+    filters = Lopata.configuration.filters
     option_combinations.each do |option_set|
       metadata = common_metadata.merge(option_set.metadata)
       scenario = Lopata::Scenario::Execution.new(title, option_set.title, metadata)
 
       unless filters.empty?
@@ -29,30 +31,16 @@
 
       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)
@@ -87,77 +75,46 @@
     @steps ||= []
   end
 
   def steps_with_hooks
     s = []
-    unless Lopata::Config.before_scenario_steps.empty?
-      s << Lopata::ActionStep.new(:setup, *Lopata::Config.before_scenario_steps)
+    unless Lopata.configuration.before_scenario_steps.empty?
+      s << Lopata::ActionStep.new(:setup, *Lopata.configuration.before_scenario_steps)
     end
 
     s += steps
 
-    unless Lopata::Config.after_scenario_steps.empty?
-      s << Lopata::ActionStep.new(:teardown, *Lopata::Config.after_scenario_steps)
+    unless Lopata.configuration.after_scenario_steps.empty?
+      s << Lopata::ActionStep.new(:teardown, *Lopata.configuration.after_scenario_steps)
     end
 
     s
   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
+    steps << Lopata::Step.new(:let) do
+      execution.let(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 option(metadata_key, variants)
-    options << Option.new(metadata_key, variants)
+    @options << Option.new(metadata_key, variants)
   end
 
   def diagonal(metadata_key, variants)
-    diagonals << Diagonal.new(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))
+    combinations = combine([OptionSet.new], options + diagonals)
+    while !diagonals.all?(&:complete?)
+      combinations << OptionSet.new(*(options + diagonals).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|
@@ -166,10 +123,10 @@
     end
     combine(combinations, rest_options)
   end
 
   def world
-    @world ||= Lopata::Config.world
+    Lopata.world
   end
 
   # Набор вариантов, собранный для одного теста
   class OptionSet
     attr_reader :variants