lopata 0.1.5 → 0.1.6

data/lib/lopata/observers/base_observer.rb

@@ -1,23 +1,34 @@
 module Lopata
   module Observers
+    # Lopata allows observe scenarios execution.
+    # All the observers are subclasses of Lopata::Observers::BaseObserver.
+    #
+    # @see Lopata::Observers::ConsoleOutputObserver for implementation example
     class BaseObserver
+      # Called before scenarios execution.
+      # All the scenarios are prepared at the moment, so it may be used to get number of scenarios
+      # via world.scenarios.count
+      #
+      # @param world [Lopata::World]
       def started(world)
       end
 
+      # Called after all scenarios execution.
+      # All the scenarios are finished at the moment, so it may be used for output statistics.
+      #
+      # @param world [Lopata::World]
       def finished(world)
       end
 
+      # Called before single scenario execution.
+      # @param world [Lopata::Scenario::Execution]
       def scenario_started(scenario)
       end
 
+      # Called after single scenario execution.
+      # @param world [Lopata::Scenario::Execution]
       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

@@ -2,26 +2,44 @@ require_relative 'backtrace_formatter'
 
 module Lopata
   module Observers
+    # @private
     class ConsoleOutputObserver < BaseObserver
+      extend Forwardable
+      # @private
+      attr_reader :output
+      # @private
+      def_delegators :output, :puts, :flush
+
+      def initialize
+        @output = $stdout
+      end
+
+      # @see Lopata::Observers::BaseObserver#finished
       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]
+        total = statuses.values.inject(0, &:+)
+        counts = statuses.map do |status, count|
+          colored("%d %s", status) % [count, status]
         end
         details = counts.empty? ? "" : "(%s)" % counts.join(', ')
         puts "#{total} scenario%s %s" % [total == 1 ? '' : 's', details]
       end
 
+      # @see Lopata::Observers::BaseObserver#scenario_finished
       def scenario_finished(scenario)
         message = "#{scenario.title} #{bold(scenario.status.to_s.upcase)}"
         puts colored(message, scenario.status)
-        return unless scenario.failed?
 
-        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?
+        statuses[scenario.status] ||= 0
+        statuses[scenario.status] += 1
+
+        if scenario.failed?
+          scenario.steps.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
+
+        flush
       end
 
       private
@@ -72,6 +90,10 @@ module Lopata
       def indent(cols, text)
         text.split("\n").map { |line| " " * cols + line }.join("\n")
       end
+
+      def statuses
+        @statuses ||= {}
+      end
     end
   end
 end

data/lib/lopata/observers/web_logger.rb

@@ -4,21 +4,18 @@ require_relative 'backtrace_formatter'
 
 module Lopata
   module Observers
+    # @private
     class WebLogger < BaseObserver
       def started(world)
-        raise "Build number is not initailzed in Lopata::Config" unless Lopata::Config.build_number
-        @client = Lopata::Client.new(Lopata::Config.build_number)
+        @client = Lopata::Client.new
         @client.start(world.scenarios.count)
+        @finished = 0
       end
 
       def scenario_finished(scenario)
-        @client.add_attempt(scenario)
+        @finished += 1
+        @client.add_attempt(scenario, @finished)
       end
-
-      # def example_pending(notification)
-      #   example = notification.example
-      #   @client.add_attempt(example, Lopata::PENDING, example.execution_result.pending_message)
-      # end
     end
   end
 
@@ -27,27 +24,30 @@ module Lopata
   PENDING = 2
   SKIPPED = 5
 
+  # @private
   class Client
     include HTTParty
-    base_uri Lopata::Config.lopata_host
 
-    attr_accessor :build_number
+    attr_reader :url, :project_code, :build_number
 
-    def initialize(build_number)
-      @build_number = build_number
+    def initialize
+      params = Lopata.configuration.web_logging_params
+      raise "Web logging is not initailzed" unless params
+      @url = HTTParty.normalize_base_uri(params[:url])
+      @project_code = params[:project_code]
+      @build_number = params[:build_number]
     end
 
     def start(count)
       @launch_id = JSON.parse(post("/projects/#{project_code}/builds/#{build_number}/launches.json", body: {total: count}).body)['id']
     end
 
-    def add_attempt(scenario)
+    def add_attempt(scenario, finished)
       status = scenario.failed? ? Lopata::FAILED : Lopata::PASSED
-      steps = scenario.steps_in_running_order.map { |s| step_hash(s) }
-      request = { status: status, steps: steps }
+      steps = scenario.steps.map { |s| step_hash(s) }
+      request = { status: status, steps: steps, launch: { id: @launch_id, finished: finished } }
       test = test_id(scenario)
       post("/tests/#{test}/attempts.json", body: request)
-      inc_finished
     end
 
     def step_hash(step)
@@ -82,32 +82,25 @@ module Lopata
 
     private
 
-    def get_json(url)
-      JSON.parse(self.class.get(url).body)
+    def get_json(path)
+      JSON.parse(self.class.get(path, base_uri: url).body)
     end
 
     def post(*args)
-      self.class.post(*args)
+      self.class.post(*with_base_uri(args))
     end
 
     def patch(*args)
-      self.class.patch(*args)
+      self.class.patch(*with_base_uri(args))
     end
 
-    def inc_finished
-      @finished ||= 0
-      @finished += 1
-      response = patch("/launches/#{@launch_id}",
-        body: { finished: @finished }.to_json,
-        headers: { 'Content-Type' => 'application/json', 'Accept' => 'application/json' })
-      if response.code == 404
-        puts 'Launch has been cancelled. Exit.'
-        exit!
+    def with_base_uri(args = [])
+      if args.last.is_a? Hash
+        args.last[:base_uri] = url
+      else
+        args << { base_uri: url }
       end
-    end
-
-    def project_code
-      Lopata::Config.lopata_code
+      args
     end
 
     def error_message_for(step)

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,27 +33,23 @@ module Lopata
 
     no_commands do
       def configure_from_options
-        Lopata::Config.ops = {
-          focus: options[:focus],
-          users: options[:users],
-          build: options[:build],
-          env:   options[:env],
-          keep:  options[:keep],
-        }
-        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::Config.filters << -> (scenario) { scenario.title.include?(text) }
+        Lopata.configuration.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) }
+        to_rerun = Lopata::Client.new.to_rerun
+        Lopata.configuration.filters << -> (scenario) { to_rerun.include?(scenario.title) }
       end
     end
   end

data/lib/lopata/scenario.rb

@@ -21,7 +21,9 @@ class Lopata::Scenario
   private
 
   def method_missing(method, *args, &block)
-    if metadata.keys.include?(method)
+    if execution.let_methods.include?(method)
+      instance_exec(*args, &execution.let_methods[method])
+    elsif metadata.keys.include?(method)
       metadata[method]
     else
       super
@@ -29,7 +31,7 @@ class Lopata::Scenario
   end
 
   def respond_to_missing?(method, *)
-    metadata.keys.include?(method) or super
+    execution.let_methods.include?(method) or metadata.keys.include?(method) or super
   end
 
   class Execution
@@ -38,6 +40,7 @@ class Lopata::Scenario
     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)
@@ -45,8 +48,9 @@ class Lopata::Scenario
 
     def run
       @status = :running
+      sort_steps
       world.notify_observers(:scenario_started, self)
-      steps_in_running_order.each(&method(:run_step))
+      steps.each(&method(:run_step))
       @status = steps.any?(&:failed?) ? :failed : :passed
       world.notify_observers(:scenario_finished, self)
       cleanup
@@ -57,18 +61,19 @@ class Lopata::Scenario
       @current_step = step
       step.run(scenario)
       skip_rest if step.failed? && step.skip_rest_on_failure?
+      @current_step = nil
     end
 
     def world
-      @world ||= Lopata::Config.world
+      Lopata.world
     end
 
     def failed?
       status == :failed
     end
 
-    def steps_in_running_order
-      steps.reject(&:teardown_group?) + steps.select(&:teardown_group?)
+    def sort_steps
+      @steps = steps.reject(&:teardown_group?) + steps.select(&:teardown_group?)
     end
 
     def skip_rest
@@ -83,6 +88,25 @@ class Lopata::Scenario
       end
     end
 
+    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
+
     def cleanup
       @title = nil
       @metadata = nil

data/lib/lopata/scenario_builder.rb

@@ -1,5 +1,5 @@
 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)
@@ -10,10 +10,12 @@ class Lopata::ScenarioBuilder
 
   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)
@@ -31,26 +33,12 @@ class Lopata::ScenarioBuilder
     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
@@ -89,73 +77,42 @@ class Lopata::ScenarioBuilder
 
   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)
-  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
@@ -168,7 +125,7 @@ class Lopata::ScenarioBuilder
   end
 
   def world
-    @world ||= Lopata::Config.world
+    Lopata.world
   end
 
   # Набор вариантов, собранный для одного теста