lopata 0.1.1 → 0.1.6

data/lib/lopata/role.rb

@@ -0,0 +1,46 @@
+module Lopata
+  # @see Lopata::Configuration#role_descriptions
+  # @see Lopata::Configuration#default_role
+  module Role
+    # To be included in Lopata::Scenario
+    module Methods
+      def current_role
+        metadata[:as]
+      end
+    end
+
+    # To be included in Lopata::ScenarioBuilder
+    module DSL
+      def as(*args, &block)
+        @roles = args.flatten
+        @roles << Lopata::ScenarioBuilder::CalculatedValue.new(&block) if block_given?
+        @role_options = nil
+      end
+
+      def role_options
+        @role_options ||= build_role_options
+      end
+
+      def without_user
+        @without_user = true
+      end
+
+      def build_role_options
+        return [] unless roles
+        [Lopata::ScenarioBuilder::Diagonal.new(:as, roles.map { |r| [Lopata.configuration.role_descriptions[r], r] })]
+      end
+
+      def roles
+        return false if @without_user
+        @roles ||= [Lopata.configuration.default_role].compact
+      end
+
+      def diagonals
+        super + role_options
+      end
+    end
+  end
+end
+
+Lopata::Scenario.include Lopata::Role::Methods
+Lopata::ScenarioBuilder.prepend Lopata::Role::DSL

data/lib/lopata/runner.rb

@@ -1,6 +1,5 @@
 require 'thor'
 require_relative 'generators/app'
-require_relative 'config'
 require_relative 'world'
 require_relative 'loader'
 require_relative '../lopata'
@@ -11,18 +10,14 @@ module Lopata
   class Runner < Thor
     desc 'test', 'Run tests'
     option :env, default: :qa, aliases: 'e'
-    option :"no-log", type: :boolean, aliases: 'n'
-    option :focus, type: :boolean, aliases: 'f'
     option :rerun, type: :boolean, aliases: 'r'
-    option :users, type: :array, aliases: 'u'
-    option :build, aliases: 'b'
     option :keep, type: :boolean, aliases: 'k'
     option :text, aliases: 't'
     def test(*args)
       configure_from_options
       Lopata::Loader.load_shared_steps
       Lopata::Loader.load_scenarios(*args)
-      world = Lopata::Config.world
+      world = Lopata.world
       world.start
       world.scenarios.each { |s| s.run }
       world.finish
@@ -38,17 +33,23 @@ module Lopata
 
     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
+        Lopata.configure do |c|
+          c.env = options[:env].to_sym
+          c.keep = options[:keep]
+          c.load_environment
+          c.run_before_start_hooks
+        end
+        add_text_filter(options[:text]) if options[:text]
+        add_rerun_filter if options[:rerun]
+      end
+
+      def add_text_filter(text)
+        Lopata.configuration.filters << -> (scenario) { scenario.title.include?(text) }
+      end
+
+      def add_rerun_filter
+        to_rerun = Lopata::Client.new.to_rerun
+        Lopata.configuration.filters << -> (scenario) { to_rerun.include?(scenario.title) }
       end
     end
   end

data/lib/lopata/scenario.rb

@@ -3,55 +3,115 @@ 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 execution.let_methods.include?(method)
+      instance_exec(*args, &execution.let_methods[method])
+    elsif metadata.keys.include?(method)
+      metadata[method]
     else
-      metadata[metadata_key]
+      super
     end
   end
 
-  def world
-    @world ||= Lopata::Config.world
+  def respond_to_missing?(method, *)
+    execution.let_methods.include?(method) or 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
+      @let_methods = {}
+      @status = :not_runned
+      @steps = []
+      @scenario = Lopata::Scenario.new(self)
+    end
+
+    def run
+      @status = :running
+      sort_steps
+      world.notify_observers(:scenario_started, self)
+      steps.each(&method(:run_step))
+      @status = steps.any?(&:failed?) ? :failed : :passed
+      world.notify_observers(:scenario_finished, self)
+      cleanup
+    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?
+      @current_step = nil
+    end
+
+    def world
+      Lopata.world
+    end
 
-    def method_missing(method, *args, &block)
-      if metadata.keys.include?(method)
-        metadata[method]
+    def failed?
+      status == :failed
+    end
+
+    def sort_steps
+      @steps = 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
-        super
+        @metadata
       end
     end
 
-    def respond_to_missing?(method, *)
-      metadata.keys.include?(method) or super
+    def let_methods
+      if current_step
+        @let_methods.merge(current_step.let_methods)
+      else
+        @let_methods
+      end
+    end
+
+    def let(method_name, &block)
+      # define_singleton_method method_name, &block
+      base =
+        if current_step && !current_step.groups.empty?
+          current_step.groups.last.let_methods
+        else
+          @let_methods
+        end
+      base[method_name] = block
     end
-end
+
+    def cleanup
+      @title = nil
+      @metadata = nil
+      @steps = nil
+      @scenario = nil
+    end
+  end
+end

data/lib/lopata/scenario_builder.rb

@@ -1,5 +1,6 @@
 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)
@@ -9,47 +10,35 @@ class Lopata::ScenarioBuilder
 
   def initialize(title, metadata = {})
     @title, @common_metadata = title, metadata
+    @diagonals = []
+    @options = []
   end
 
   def build
+    filters = Lopata.configuration.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
     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
@@ -58,82 +47,72 @@ 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, &block)
+    step.metadata = metadata
+    steps << step
   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
+  def steps_with_hooks
+    s = []
+    unless Lopata.configuration.before_scenario_steps.empty?
+      s << Lopata::ActionStep.new(:setup, *Lopata.configuration.before_scenario_steps)
     end
-  end
 
-  def let(method_name, &block)
-    steps << Lopata::Step.new(nil) do
-      define_singleton_method method_name, &block
+    s += steps
+
+    unless Lopata.configuration.after_scenario_steps.empty?
+      s << Lopata::ActionStep.new(:teardown, *Lopata.configuration.after_scenario_steps)
     end
-  end
 
-  def build_role_options
-    return [] unless roles
-    [Diagonal.new(:as, roles.map { |r| [nil, r] })]
+    s
   end
 
-  def roles
-    return false if @without_user
-    @roles ||= [Lopata::Config.default_role].compact
+  def let(method_name, &block)
+    steps << Lopata::Step.new(:let) do
+      execution.let(method_name, &block)
+    end
   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)
-  end
-
-  def options
-    @options ||= []
-  end
-
-  def diagonals
-    @diagonals ||= []
+    @diagonals << Diagonal.new(metadata_key, variants)
   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
@@ -146,7 +125,7 @@ class Lopata::ScenarioBuilder
   end
 
   def world
-    @world ||= Lopata::Config.world
+    Lopata.world
   end
 
   # Набор вариантов, собранный для одного теста
@@ -187,10 +166,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 +181,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 +224,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 +251,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