lopata 0.1.25 → 0.1.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52985977beeccefe3ae15ad9686dad98119c0f201007ce353d27e182bfb11eaa
-  data.tar.gz: 5c21409a5efb926421e8d829ab2051dad6f4a4e914ee2e9500c01c28e8b083c7
+  metadata.gz: b0587bd058d882d2a656a1ab4f4e60ae05f756f2190e5f2b977ea9c97ca9a749
+  data.tar.gz: 97fc9b78d90d71c2ecfdd43d892380b25aed11b3ad03b5370683a601b5aa3a17
 SHA512:
-  metadata.gz: 34503bf27d89b6fca63f77fab8d0f4940f102c01de34058f73d2255258e06e1b5a26b989302b9d842502b8f79b236c80538729b15878655f35d87f0370836947
-  data.tar.gz: af7b41981f88d5c8fd03e3099d7ff7612a1d24642e7ca27f01bc914a309ed32847fcf4c1a4ae12dbfd42b167040e36c19f2a012f00295761eb4ce125fdebe565
+  metadata.gz: d20009dbd9d904fc2af94df682c2964b74d269871c7d331eacf26536c365b39d830a03308c1aa6eb7399022e21d63a98cb1ec60dbf6d8bac876be1484db725ae
+  data.tar.gz: adf29771c6c191fca1e1dcf7954d5a21a2ae0acf28fabeb94886a8d82e83e4120f74d4610febaace4049ac5be20d28927c0076b9cc1590b8b3fae473e0177fd7

data/lib/lopata/observers/console_output_observer.rb

@@ -1,5 +1,4 @@
 require_relative 'backtrace_formatter'
-require_relative 'group_tree'
 require 'forwardable'
 
 module Lopata
@@ -34,25 +33,27 @@ module Lopata
         statuses[scenario.status] ||= 0
         statuses[scenario.status] += 1
 
-        if scenario.failed?
-          GroupTree.steps_hierarhy(scenario.steps).walk_through do |step|
-            if step.is_a?(Lopata::StepExecution)
-              next unless step.loggable?
-              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?
-            else # GroupTree
-              group = step
-              if %i{ passed skipped }.include?(group.status)
-                puts colored("  #{status_marker(group.status)} #{group.title}", group.status)
-                false
-              else
-                true
-              end
+        log_steps(scenario.steps) if scenario.failed?
+
+        flush
+      end
+
+      # @private
+      def log_steps(steps)
+        steps.each do |step|
+          next unless step.loggable?
+          if step.group?
+            status = step.status
+            if %i{ passed skipped ignored }.include?(status)
+              puts colored("  #{status_marker(step.status)} #{step.title}", status)
+            else
+              log_steps(step.steps)
             end
+          else
+            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
@@ -61,7 +62,7 @@ module Lopata
         case status
         when :failed then red(text)
         when :passed then green(text)
-        when :skipped then cyan(text)
+        when :skipped, :ignored then cyan(text)
         when :pending then yellow(text)
         else text
         end

data/lib/lopata/observers/web_logger.rb

@@ -1,7 +1,6 @@
 require 'httparty'
 require 'json'
 require_relative 'backtrace_formatter'
-require_relative 'group_tree'
 
 module Lopata
   module Observers
@@ -47,26 +46,15 @@ module Lopata
       @launch_id = JSON.parse(post("/projects/#{project_code}/builds/#{build_number}/launches.json", body: {total: count}).body)['id']
     end
 
+    # Create test stubs for all the scenarios within then build
+    def init_scenarios(world)
+      post("/projects/#{project_code}/builds/#{build_number}/tests.json", 
+        body: { scenarios: world.scenarios.map { { title: _1.title } } })
+    end
+
     def add_attempt(scenario, finished)
       status = scenario.failed? ? Lopata::FAILED : Lopata::PASSED
-      steps = []
-      GroupTree.steps_hierarhy(scenario.steps).walk_through do |step|
-        if step.is_a?(Lopata::StepExecution)
-          next unless step.loggable?
-          steps << step_hash(step)
-        else # GroupTree
-
-          group = step
-          if %i{ passed skipped }.include?(group.status)
-            steps << group_hash(group)
-            false
-          else
-            true
-          end
-        end
-      end
-
-      steps = scenario.steps.select(&:loggable?).map { |s| step_hash(s) }
+      steps = build_hashes(scenario.steps)
       request = { status: status, steps: steps, launch: { id: @launch_id, finished: finished } }
       test = test_id(scenario)
       post("/tests/#{test}/attempts.json", body: request)
@@ -76,6 +64,23 @@ module Lopata
       puts e.backtrace
     end
 
+    def build_hashes(steps)
+      hashes = []
+      steps.each do |step|
+        next unless step.loggable?
+        if step.group?
+          if %i{ passed skipped ignored }.include?(step.status)
+            hashes << group_hash(step)
+          else
+            hashes += build_hashes(step.steps)
+          end
+        else
+          hashes << step_hash(step)
+        end
+      end
+      hashes
+    end
+
     def step_hash(step)
       hash = { status: step.status, title: step.title }
       if step.failed?

data/lib/lopata/runner.rb

@@ -15,6 +15,7 @@ module Lopata
     option :keep, type: :boolean, aliases: 'k'
     option :text, aliases: 't'
     option :list, type: :boolean, aliases: 'l'
+    option :init, type: :boolean, aliases: 'i'
     def test(*args)
       trap_interrupt
       configure_from_options
@@ -22,6 +23,8 @@ module Lopata
       Lopata::Loader.load_scenarios(*args)
       if options[:list]
         list_scenarios
+      elsif
+        init_scenarios
       else
         run_scenarios
       end
@@ -64,6 +67,11 @@ module Lopata
         Lopata.world.scenarios.each { |s| puts s.title }
       end
 
+      def init_scenarios
+        client = Lopata::Client.new
+        client.init_scenarios(Lopata.world)
+      end
+
       def run_scenarios
         world = Lopata.world
         world.notify_observers(:started, world)

data/lib/lopata/scenario.rb

@@ -45,8 +45,9 @@ class Lopata::Scenario
 
   # @private
   def method_missing(method, *args, &block)
-    if execution.let_methods.include?(method)
-      execution.let_methods[method].call_in_scenario(self, *args)
+
+    if (let_method = execution.find_let_method(method))
+      let_method.call_in_scenario(self, *args)
     elsif metadata.keys.include?(method)
       metadata[method]
     else
@@ -56,21 +57,18 @@ class Lopata::Scenario
 
   # @private
   def respond_to_missing?(method, *)
-    execution.let_methods.include?(method) or metadata.keys.include?(method) or super
+    execution.find_let_method(method) or metadata.keys.include?(method) or super
   end
 
   # @private
   # Scenario execution and live-cycle information
   class Execution
-    attr_reader :scenario, :status, :steps, :title, :current_step
-
-    def initialize(title, options_title, metadata = {})
-      @title = [title, options_title].compact.reject(&:empty?).join(' ')
-      @metadata = metadata
-      @let_methods = {}
-      @status = :not_runned
-      @steps = []
+    attr_reader :scenario, :current_step, :top
+
+    def initialize(title, metadata = {})
       @scenario = Lopata::Scenario.new(self)
+      @top = Lopata::GroupExecution.new(Lopata::TopStep.new(title, metadata: metadata), nil, steps: [])
+      @current_step = @top
     end
 
     # Provide a human-readable representation of this class
@@ -79,32 +77,42 @@ class Lopata::Scenario
     end
     alias to_s inspect
 
+    def steps
+      top.steps
+    end
+
     def run
-      @status = :running
-      sort_steps
       world.notify_observers(:scenario_started, self)
-      steps.each(&method(:run_step))
-      @status = steps.any?(&:failed?) ? :failed : :passed
+      run_step(top)
       world.notify_observers(:scenario_finished, self)
       cleanup
     end
 
     def run_step(step)
-      return if step.skipped? || step.ignored?
-      groups = step.groups 
-      if groups.length > 0 && groups != @current_groups
-        @current_groups = groups
-        condition = groups.last.condition
-        if condition&.dynamic? && !condition.match_dynamic?(scenario)
-          step.ignored!
-          ignore_groups(groups)
-          return
+      @current_step = step
+      return :skipped if step.skipped?
+      return :ignored if step.ignored?
+      if step.condition&.dynamic && !step.condition.match_dynamic?(scenario)
+        step.ignored!
+        return :ignored
+      end
+      if step.group?
+        skip_rest = false
+        step.steps.each do
+          if _1.teardown?
+            run_step(_1)
+          elsif skip_rest
+            _1.skip!
+          else
+            run_step(_1)
+            skip_rest = true if _1.failed? && _1.skip_rest_on_failure?
+          end 
         end
+        step.status!
+      else
+        step.run(scenario)
+        step.status
       end
-      @current_step = step
-      step.run(scenario)
-      skip_rest if step.failed? && step.skip_rest_on_failure?
-      @current_step = nil
     end
 
     def world
@@ -115,55 +123,47 @@ class Lopata::Scenario
       status == :failed
     end
 
-    def sort_steps
-      @steps = steps.reject(&:teardown_group?) + steps.select(&:teardown_group?)
+    def metadata
+      current_step.metadata
     end
 
-    def skip_rest
-      steps.select { |s| s.status == :not_runned && !s.teardown? }.each(&:skip!)
+    def let_methods
+      current_step.let_methods
     end
 
-    def ignore_groups(groups)
-      steps.select { _1.status == :not_runned && _1.groups.take(groups.length) == groups }.each(&:ignored!)
+    def find_let_method(name)
+      current_step.find_let_method(name)
     end
 
-    def metadata
-      if current_step
-        @metadata.merge(current_step.metadata)
-      else
-        @metadata
-      end
+    def title
+      top.title
     end
 
-    def let_methods
-      if current_step
-        @let_methods.merge(current_step.let_methods)
-      else
-        @let_methods
-      end
+    def status
+      top.status
     end
 
     def let_base
-      if current_step && !current_step.groups.empty?
-        current_step.groups.last.let_methods
+      if current_step.group?
+        current_step
       else
-        @let_methods
+        current_step.parent
       end
     end
 
     def let(method_name, &block)
-      let_base[method_name] = LetMethod.new(&block)
+      let_base.add_let_method(method_name, LetMethod.new(&block))
     end
 
     def let!(method_name, &block)
-      let_base[method_name] = LetBangMethod.new(&block)
+      let_base.add_let_method(method_name, LetBangMethod.new(&block))
     end
 
     def cleanup
       @title = nil
-      @metadata = nil
-      @steps = nil
       @scenario = nil
+      @top = nil
+      @current_step = nil
     end
   end
 

data/lib/lopata/scenario_builder.rb

@@ -38,16 +38,20 @@ class Lopata::ScenarioBuilder
     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)
-
+      scenario_title = [title, option_set.title].compact.reject(&:empty?).join(' ')
+      scenario = Lopata::Scenario::Execution.new(scenario_title, metadata)
+    
       unless filters.empty?
         next unless filters.all? { |f| f[scenario] }
       end
 
+      exec_steps = []
       steps_with_hooks.each do |step|
         next if step.condition && !step.condition.match?(scenario)
-        step.execution_steps(scenario).each { |s| scenario.steps << s }
+        step.execution_steps(scenario, parent: scenario.top).each { |s| exec_steps << s }
       end
+      scenario.steps.push(*exec_steps.reject(&:teardown?))
+      scenario.steps.push(*exec_steps.select(&:teardown?))
 
       world.scenarios << scenario
     end

data/lib/lopata/step.rb

@@ -7,12 +7,13 @@ module Lopata
     # metadata overrien by the step.
     attr_accessor :metadata
 
-    def initialize(method_name, *args, condition: nil, shared_step: nil, &block)
+    def initialize(method_name, *args, condition: nil, shared_step: nil, metadata: {}, &block)
       @method_name = method_name
       @args = args
       @block = block
       @shared_step = shared_step
       @condition = condition
+      @metadata = metadata
       initialized! if defined? initialized!
     end
 
@@ -22,31 +23,31 @@ module Lopata
       base_title
     end
 
-    def execution_steps(scenario, groups: [])
+    def execution_steps(scenario, parent:)
       return [] if condition && !condition.match?(scenario)
       return [] unless block
-      [StepExecution.new(self, groups, condition: condition, &block)]
+      [StepExecution.new(self, parent, condition: condition, &block)]
     end
   end
 
   # @private
   # Used for action, setup, teardown, verify
   class ActionStep < Step
-    def execution_steps(scenario, groups: [])
+    def execution_steps(scenario, parent:)
       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)
+            steps += shared_step.execution_steps(scenario, parent: parent)
           end
         elsif step.is_a?(Proc)
-          steps << StepExecution.new(self, groups, condition: condition, &step)
+          steps << StepExecution.new(self, parent, condition: condition, &step)
         end
       end
-      steps << StepExecution.new(self, groups, condition: condition, &block) if block
-      steps.reject { |s| !s.block }
+      steps << StepExecution.new(self, parent, condition: condition, &block) if block
+      steps
     end
 
     def separate_args(args)
@@ -74,22 +75,18 @@ module Lopata
   # Used for context
   class GroupStep < Step
 
-    def execution_steps(scenario, groups: [])
+    def execution_steps(scenario, parent: nil)
       steps = []
       return steps if condition && !condition.match?(scenario)
+      group = GroupExecution.new(self, parent, steps: steps, condition: condition)
       @steps.each do |step|
-        steps += step.execution_steps(scenario, groups: groups + [self])
+        steps += step.execution_steps(scenario, parent: group)
       end
-      steps.reject! { |s| !s.block }
-      steps.reject { |s| s.teardown_group?(self) } + steps.select { |s| s.teardown_group?(self) }
+      group.steps.push(*steps.reject(&:teardown?))
+      group.steps.push(*steps.select(&:teardown?))
+      [group]
     end
 
-    def let_methods
-      @let_methods ||= {}
-    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)
@@ -99,70 +96,60 @@ module Lopata
     end
   end
 
-  #@private
-  class StepExecution
-    attr_reader :step, :status, :exception, :block, :pending_message, :groups, :condition
+  # @private
+  class TopStep < Step
+    def initialize(title, metadata: {})
+      super(:top, title, metadata: metadata)
+    end
+ end
+
+  # @private
+  # Abstract execution step. Composition, may be group or step.
+  class BaseExecution
+    attr_reader :step, :status, :parent, :condition
     extend Forwardable
     def_delegators :step, :method_name
 
-    class PendingStepFixedError < StandardError; end
-
-    def initialize(step, groups, condition: nil, &block)
+    def initialize(step, parent, condition: nil)
       @step = step
+      @parent = parent
       @status = :not_runned
-      @exception = nil
-      @block = block
-      @groups = groups
       @condition = condition
     end
 
-    def title
-      "#{group_title}#{step.title}"
+    def group?
+      false
     end
 
-    def group_title
-      groups.map { |g| "#{g.title}: " }.join
+    def top?
+      !parent
     end
 
-    def run(scenario)
-      @status = :running
-      begin
-        unless check_dynamic_condition?(scenario)
-          @status = :ignored
-          return
-        end
-        run_step(scenario)
-        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 unless pending?
-        @exception = e
-      end
+    def teardown?
+      %i{ teardown cleanup }.include?(method_name)
     end
 
-    def run_step(scenario)
-      return unless block
-      scenario.instance_exec(&block)
+    def parents
+      result = []
+      prnt = parent
+      while prnt
+        result << prnt
+        prnt = prnt.parent
+      end
+      result
     end
 
-    def check_dynamic_condition?(scenario)
-      dynamic_conditions.each do
-        return false unless _1.match_dynamic?(scenario)
+     # Step metadata is a combination of metadata given for step and all contexts (groups) the step included
+    def metadata
+      result = step.metadata || {}
+      if parent
+        result = parent.metadata.merge(result)
       end
-      true
+      result
     end
 
-    def dynamic_conditions
-      conds = []
-      conds << condition if condition&.dynamic?
-      groups.each do
-        conds << _1.condition if _1.condition&.dynamic?
-      end
-      conds
+    def find_let_method(name)
+      parent&.find_let_method(name)
     end
 
     def failed?
@@ -189,13 +176,12 @@ module Lopata
       @status = :skipped
     end
 
-    def pending?
-      status == :pending
-    end
-
-    def pending!(message = nil)
-      @status = :pending
-      @pending_message = message
+    def title
+      if parent && !parent.top?
+        "#{parent.title}: #{step.title}"
+      else
+        step.title
+      end
     end
 
     # Need log this step.
@@ -204,30 +190,96 @@ module Lopata
       not %i{ let let! }.include?(method_name)
     end
 
-    def teardown?
-      %i{ teardown cleanup }.include?(method_name)
+    def skip_rest_on_failure?
+      %i{ setup action }.include?(method_name)
     end
+  end
 
-    def teardown_group?(group = nil)
-      teardown? && self.groups.last == group
+  # @private
+  class GroupExecution < BaseExecution
+    attr_reader :steps
+
+    def initialize(step, parent, condition: nil, steps:)
+      super(step, parent, condition: condition)
+      @steps = steps
+      @let_methods = {}
     end
 
-    def in_group?(group)
-      groups.include?(group)
+    def group?
+      true
     end
 
-    def skip_rest_on_failure?
-      %i{ setup action }.include?(method_name)
+    def status!
+      # return @status if @status
+      statuses = steps.map(&:status!).uniq
+      @status = 
+        if statuses.length == 1
+          statuses.first
+        elsif statuses.include?(:failed)
+          :failed
+        else
+          statuses.first || :skipped
+        end
+      @status = :passed if @status == :pending
+      @status
     end
 
-    # Step metadata is a combination of metadata given for step and all contexts (groups) the step included
-    def metadata
-      (groups + [step]).compact.inject({}) { |merged, part| merged.merge(part.metadata || {}) }
+    def find_let_method(name)
+      @let_methods[name] || parent&.find_let_method(name)
+    end
+
+    def add_let_method(name, method)
+      @let_methods[name] = method
+    end
+
+    def ignored!
+      @status = :ignored
+      steps.each(&:ignored!)
+    end
+  end
+
+  # @private
+  class StepExecution < BaseExecution
+    attr_reader :exception, :block, :pending_message
+
+    class PendingStepFixedError < StandardError; end
+
+    def initialize(step, parent, condition: nil, &block)
+      super(step, parent, condition: condition)
+      @exception = nil
+      @block = block
+    end
+
+    alias status! status
+
+    def run(scenario)
+      @status = :running
+      begin
+        run_step(scenario)
+        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 unless pending?
+        @exception = e
+      end
     end
 
-    # Step methods is a combination of let_methods for all contexts (group) the step included
-    def let_methods
-      (groups).compact.inject({}) { |merged, part| merged.merge(part.let_methods || {}) }
+    def run_step(scenario)
+      return unless block
+      scenario.instance_exec(&block)
+    end
+
+    def pending?
+      status == :pending
+    end
+
+    def pending!(message = nil)
+      @status = :pending
+      @pending_message = message
     end
   end
 end

data/lib/lopata/version.rb

@@ -1,6 +1,6 @@
 module Lopata
   # @private
   module Version
-    STRING = '0.1.25'
+    STRING = '0.1.27'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lopata
 version: !ruby/object:Gem::Version
-  version: 0.1.25
+  version: 0.1.27
 platform: ruby
 authors:
 - Alexey Volochnev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-05 00:00:00.000000000 Z
+date: 2023-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -107,7 +107,6 @@ files:
 - lib/lopata/observers/backtrace_formatter.rb
 - lib/lopata/observers/base_observer.rb
 - lib/lopata/observers/console_output_observer.rb
-- lib/lopata/observers/group_tree.rb
 - lib/lopata/observers/web_logger.rb
 - lib/lopata/role.rb
 - lib/lopata/runner.rb
@@ -139,5 +138,5 @@ requirements: []
 rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
-summary: lopata-0.1.25
+summary: lopata-0.1.27
 test_files: []

data/lib/lopata/observers/group_tree.rb

@@ -1,64 +0,0 @@
-module Lopata
-  GroupTree = Struct.new(:group, :items, :title) do
-    def status
-      # return @status if @status
-      statuses = items.map(&:status).uniq
-      @status = 
-        if statuses.length == 1
-          statuses.first
-        elsif statuses.include?(:failed)
-          :failed
-        elsif 
-          statuses.first
-        end
-      @status
-    end
-
-    # Returns steps hierarhy: Group with nestet setps or groups
-    def self.steps_hierarhy(steps)
-      top = GroupTree.new(nil, [], '')
-      hierarhy = [top]
-      current_groups = []
-      steps.each do |step|
-        if step.groups == current_groups
-          hierarhy.last.items << step
-        else
-          # ensure hierarhy to is in current step tree - remove from hierary all groups not in new tree.
-          while hierarhy.last.group && !step.groups.include?(hierarhy.last.group)
-            hierarhy.pop
-          end
-          if hierarhy.last.group == step.groups.last
-            hierarhy.last.items << step
-          else
-            group_rest = step.groups.dup
-            while hierarhy.last.group && group_rest.first != hierarhy.last.group
-              group_rest.shift
-            end
-            group_rest.shift if group_rest.first == hierarhy.last.group
-            group_rest.each do
-              title = (hierarhy.map(&:group).compact + [_1]).map(&:title).join(': ')
-              group = GroupTree.new(_1, [], title)
-              hierarhy.last.items << group
-              hierarhy << group
-            end
-            hierarhy.last.items << step
-          end
-          current_groups = step.groups
-        end
-      end
-      return top
-    end
-
-    def walk_through(&block)
-      items.each do |step|
-        if step.is_a?(Lopata::StepExecution)
-          yield step
-        else # GroupTree
-          group = step
-          go_dipper = yield group
-          group.walk_through(&block) if go_dipper
-        end
-      end
-    end
-  end
-end