lopata 0.1.1 → 0.1.6

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,69 +1,48 @@
 module Lopata
   class Step
-    attr_reader :block, :status, :exception, :args, :condition
+    attr_reader :block, :args, :condition, :method_name, :shared_step
+    # 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, &block)
       @method_name = method_name
       @args = args
-      @status = :not_started
       @block = block
-      @exception = nil
-      @condition = condition || Lopata::Condition::EMPTY
-    end
-
-    def run(scenario)
-      @status = :running
-      world.notify_observers(:step_started, self)
-      begin
-        run_step(scenario)
-        @status = :passed
-      rescue Exception => e
-        @status = :failed
-        @exception = e
-      end
-      world.notify_observers(:step_finished, self)
-    end
-
-    def run_step(scenario)
-      scenario.instance_exec(&block) if block
-    end
-
-    def world
-      @world ||= Lopata::Config.world
+      @shared_step = shared_step
+      @condition = condition
+      initialized! if defined? initialized!
     end
 
-    def failed?
-      status == :failed
+    def title
+      base_title = args.first
+      base_title ||= shared_step && "#{method_name.capitalize} #{shared_step.name}" || "Untitled #{method_name}"
+      base_title
     end
 
-    def passed?
-      status == :passed
-    end
-
-    def teardown?
-      %i{ teardown cleanup }.include?(@method_name)
-    end
-
-    def pre_steps(scenario)
-      []
+    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 pre_steps(scenario)
+    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|
-            steps += shared_step.pre_steps(scenario)
-            steps << 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 << Lopata::Step.new(method_name, &step)
+          steps << StepExecution.new(self, groups, &step)
         end
       end
-      steps
+      steps << StepExecution.new(self, groups, &block) if block
+      steps.reject { |s| !s.block }
     end
 
     def separate_args(args)
@@ -82,5 +61,125 @@ module Lopata
       end.flatten
     end
 
+    def title
+      shared_step && "#{method_name.capitalize} #{shared_step.name}" || "Untitled #{method_name}"
+    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
+
+    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)
+      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, :method_name
+
+    class PendingStepFixedError < StandardError; end
+
+    def initialize(step, groups, &block)
+      @step = step
+      @status = :not_runned
+      @exception = nil
+      @block = block
+      @groups = groups
+    end
+
+    def title
+      group_title = groups.map { |g| "#{g.title}: " }.join
+      "#{group_title}#{step.title}"
+    end
+
+    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
+
+    def run_step(scenario)
+      return unless block
+      scenario.instance_exec(&block)
+    end
+
+    def failed?
+      status == :failed
+    end
+
+    def passed?
+      status == :passed
+    end
+
+    def skipped?
+      status == :skipped
+    end
+
+    def skip!
+      @status = :skipped
+    end
+
+    def pending?
+      status == :pending
+    end
+
+    def pending!(message = nil)
+      @status = :pending
+      @pending_message = message
+    end
+
+    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
+      (groups + [step]).compact.inject({}) { |merged, part| merged.merge(part.metadata) }
+    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) }
+    end
   end
-end
+end

data/lib/lopata/version.rb

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

data/lib/lopata/world.rb

@@ -22,8 +22,10 @@ class Lopata::World
     end
   end
 
+  private
+
   # Define observers based on configuration
   def observers
-    @observers ||= [Lopata::Observers::ConsoleOutputObserver.new]
+    Lopata.configuration.observers
   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.6
 platform: ruby
 authors:
 - Alexey Volochnev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-14 00:00:00.000000000 Z
+date: 2020-06-01 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,24 +90,24 @@ files:
 - README.md
 - exe/lopata
 - lib/lopata.rb
+- lib/lopata/active_record.rb
 - lib/lopata/condition.rb
-- lib/lopata/config.rb
+- lib/lopata/configuration.rb
+- lib/lopata/environment.rb
+- lib/lopata/factory_bot.rb
 - lib/lopata/generators/app.rb
-- lib/lopata/generators/templates/.rspec
 - lib/lopata/generators/templates/Gemfile
 - lib/lopata/generators/templates/Lopatafile
 - lib/lopata/generators/templates/config/environments/qa.yml
 - lib/lopata/generators/templates/config/initializers/capybara.rb
-- lib/lopata/generators/templates/spec/spec_helper.rb
 - 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/role.rb
 - lib/lopata/runner.rb
 - lib/lopata/scenario.rb
 - lib/lopata/scenario_builder.rb
@@ -137,5 +137,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: lopata-0.1.1
+summary: lopata-0.1.6
 test_files: []

data/lib/lopata/config.rb

@@ -1,101 +0,0 @@
-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
-
-    def init(env)
-      require 'yaml'
-      @config = {}
-      config_filename = "./config/environments/#{env}.yml"
-      @config = YAML::load(File.open(config_filename)) if File.exists?(config_filename)
-      init_db
-      @role_descriptions ||= {}
-      # init_includes
-    end
-
-    def [](key)
-      @config[key]
-    end
-
-    %w{url name readonly}.each do |opt|
-      define_method opt do
-        raise "Lopata::Config unititlalized, use Lopata::Config#init(env) to set environment" unless @config
-        @config[opt]
-      end
-    end
-
-    def init_db
-      ActiveRecord::Base.establish_connection(@config['db']) if @config['db']
-    end
-
-    def init_rspec
-      require 'lopata/rspec/dsl'
-      require 'lopata/rspec/role'
-      ::RSpec.configure do |c|
-        c.include Lopata::RSpec::DSL
-        c.include Lopata::RSpec::Role
-      end
-      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
-        end
-      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 initialize_test
-      @before_start.call if @before_start
-    end
-
-    def world
-      @world ||= Lopata::World.new
-    end
-
-    def add_observer(observer)
-      world.observers << observer
-    end
-  end
-end

data/lib/lopata/generators/templates/.rspec

@@ -1,3 +0,0 @@
---color
---format documentation
---require spec_helper

data/lib/lopata/generators/templates/spec/spec_helper.rb

@@ -1,2 +0,0 @@
-Lopata::Config.role_descriptions = { user: 'User' }
-Lopata::Config.default_role = :user

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