lopata 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51ff4a162c7617388f8856b342449e1475f2438d8a44a6c58c6168373b144969
-  data.tar.gz: 10580190d2a63826f971d1730523eacc34ed818b634329da1635db07d2627d27
+  metadata.gz: 7f4b4814d88cd3b9da3a34159e3c1c977d05cbb0504d3dc0b2ab8034044dfbf0
+  data.tar.gz: 378e5a3c346c64cb4430577dcfab31cfefd54a2c8e8ee30046609cf10e1bdba4
 SHA512:
-  metadata.gz: 76f4fffc7d6755eb63d45a3297177c25b2e947c101dfad38b7a39e8bb474f00e3874d3b3fcf939a81d3ad550cc7d18335ac998104f0b0436db239d1f4688a0f5
-  data.tar.gz: '086e6cb580e94035e78607daa4a5ba6a5caf2211e37bc0e5cd9aa7cb1e2579fc22889e6fb90e17e6b4f290016a70d76f86d1d93d307d19e964b7584a3bee0451'
+  metadata.gz: ff0498d9c9b665d52f5a8d1e65cdc6dc9078f0df1cd4f7fd831393af04ee564a5cf9a9f55305bd4423ff92062cdb7fd4a728bb2be657f196f91447faddffa941
+  data.tar.gz: 063a3914c5e5dd088ad56e37ea527c540e8dc82f0d56e7dca4564e61699541000e4d801a80898b2d89eb6719cfd4d1a887d3884a52335f0e6339ffc9a91569fb

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/lib/lopata.rb

@@ -6,6 +6,7 @@ require 'lopata/scenario'
 require 'lopata/step'
 require 'lopata/shared_step'
 
+# Namespace for all Lopata code.
 module Lopata
   # Define the scenario.
   # @see Lopata::ScenarioBuilder.define
@@ -34,7 +35,7 @@ module Lopata
   #       end
   #     end
   # @param name [String] shared step unique name
-  # @param block shared step action sequence definition
+  # @param block [Block] shared step action sequence definition
   def self.shared_step(name, &block)
     Lopata::SharedStep.register(name, &block)
   end

data/lib/lopata/active_record.rb

@@ -71,6 +71,39 @@ module Lopata
       def reload(*objects)
         objects.flatten.compact.each(&:reload)
       end
+
+      # Marks object to be destroyed at the end of scenario
+      #
+      # @param object [ActiveRecord::Base] the object to be destoryed at the end of scenario
+      # @return the given object, so chains can be build
+      def cleanup_later(object)
+        return nil unless object
+        @created_objects ||= []
+        @created_objects << object
+        object
+      end
+
+      # Find ActiveRecord object of given class by params.
+      # Marks the returned object to be destroyed at the end of scenario.
+      #
+      # @example
+      #     action do
+      #       # UI actions creating the user
+      #       @user = find_created(User, username: 'testuser')
+      #     end
+      #     it 'created' do
+      #       expect(@user).to_not be_nil
+      #     end
+      #     # No cleanup needed
+      #     # cleanup :user
+      #
+      # @param cls [Class] active record model class
+      # @param params [Hash] options for record finding
+      # @return [ActiveRecord::Base, nil] the object or nil if not found
+      # @see #cleanup_later called on the hood
+      def find_created(cls, params)
+        cleanup_later cls.where(params).take
+      end
     end
 
     # To be included in Lopata::ScenarioBuilder. The methods may be used in build time.
@@ -92,6 +125,10 @@ module Lopata
   end
 end
 
+Lopata.configure do |c|
+  c.after_scenario { cleanup @created_objects }
+end
+
 params = Lopata.environment['db']
 ActiveRecord::Base.establish_connection(params) if params
 

data/lib/lopata/factory_bot.rb

@@ -1,23 +1,63 @@
 require_relative 'active_record'
 
 module Lopata
+  # Helpers for FactoryBot usage in tests.
+  #
+  # Make helpers available in scenarios by
+  #
+  #     require 'lopata/factory_bot'
+  #
+  # Automatically adds ActiveRecord helpers.
+  # @see Lopata::ActiveRecord
+  #
+  # Allows to create ActiveRecord object by FactoryBot definitions.
+  # All the objects created by FactoryBot helpers will be destroyed automatically
+  # at the end of scenario.
+  # @see Lopata::ActiveRecord::Methods#cleanup
+  #
+  # @example
+  #
+  #     # Configure db connection at config/environments/qa.yml like rails:
+  #     # db:
+  #     #   adapter: postgresql
+  #     #   host: your.database.host
+  #     #   username: username
+  #     #   password: password
+  #     #   database: database
+  #     require 'active_record'
+  #     require 'factory_bot'
+  #     require 'lopata/facotory_bot'
+  #
+  #     class User < ActiveRecord::Base; end
+  #
+  #     FactoryBot.define do
+  #       factory :user do
+  #         username { 'testuser' }
+  #       end
+  #     end
+  #
+  #     Lopata.define 'User creation' do
+  #       setup do
+  #         @user = create(:user)
+  #       end
+  #       # No cleanup needed - @user will be destroyed automatically
+  #       # cleanup :user
+  #
+  #       it 'works' do
+  #         expect(@user).to_not be_nil
+  #       end
+  #     end
+  #
   module FactoryBot
     # To be included in Lopata::Scenario
     module Methods
+      # Wrapper for FactoryBot#create
+      # Calls the FactoryBot#create with given paramters and returns it result.
+      # Additionally store the created object for destroying at the end of scenario.
+      # @see Lopata::ActiveRecord::Methods#cleanup
       def create(*params)
         cleanup_later ::FactoryBot.create(*params)
       end
-
-      def find_created(cls, params)
-        cleanup_later cls.where(params).take
-      end
-
-      def cleanup_later(object)
-        return nil unless object
-        @created_objects ||= []
-        @created_objects << object
-        object
-      end
     end
 
     # To be included in Lopata::ScenarioBuilder
@@ -29,8 +69,4 @@ end
 Lopata::Scenario.include Lopata::FactoryBot::Methods
 Lopata::ScenarioBuilder.include Lopata::FactoryBot::DSL
 
-Lopata.configure do |c|
-  c.after_scenario { cleanup @created_objects }
-end
-
 ::FactoryBot.find_definitions

data/lib/lopata/generators/app.rb

@@ -1,5 +1,7 @@
 module Lopata
+  # @private
   module Generators
+    # @private
     class App < Thor::Group
       include Thor::Actions
       argument :name

data/lib/lopata/id.rb

@@ -1,4 +1,5 @@
 module Lopata
+  # @private
   module Id
     extend self
 

data/lib/lopata/loader.rb

@@ -1,3 +1,4 @@
+# @private
 module Lopata::Loader
   extend self
 
@@ -20,6 +21,7 @@ module Lopata::Loader
     Dir["scenarios/**/*.rb"].each { |f| load File.expand_path(f) }
   end
 
+  # Loads all shared steps from predefined paths
   def load_shared_steps
     Dir["shared_steps/**/*rb"].each { |f| load File.expand_path(f) }
   end

data/lib/lopata/observers.rb

@@ -1,3 +1,4 @@
+# @private
 module Lopata::Observers
   autoload :BaseObserver, 'lopata/observers/base_observer.rb'
   autoload :ConsoleOutputObserver, 'lopata/observers/console_output_observer.rb'

data/lib/lopata/observers/backtrace_formatter.rb

@@ -39,7 +39,7 @@ module Lopata
 
       # Extracts error message from excetion
       #
-      # @param exeption [Exception]
+      # @param exception [Exception]
       # @param include_backtrace [Boolean] whether to add formatted backtrace to output
       # @return [String] error message from excetion, incuding source code line.
       def error_message(exception, include_backtrace: false)

data/lib/lopata/observers/base_observer.rb

@@ -21,12 +21,12 @@ module Lopata
       end
 
       # Called before single scenario execution.
-      # @param world [Lopata::Scenario::Execution]
+      # @param scenario [Lopata::Scenario::Execution]
       def scenario_started(scenario)
       end
 
       # Called after single scenario execution.
-      # @param world [Lopata::Scenario::Execution]
+      # @param scenario [Lopata::Scenario::Execution]
       def scenario_finished(scenario)
       end
     end

data/lib/lopata/observers/web_logger.rb

@@ -19,9 +19,13 @@ module Lopata
     end
   end
 
+  # @private
   PASSED = 0
+  # @private
   FAILED = 1
+  # @private
   PENDING = 2
+  # @private
   SKIPPED = 5
 
   # @private

data/lib/lopata/role.rb

@@ -1,9 +1,33 @@
 module Lopata
+  # Adds ability to run scenarios by given user roles
+  #
+  # @example Usage
+  #     require 'lopata/role'
+  #     Lopata.configure do |c|
+  #       c.role_descriptions = {
+  #         user: 'User',
+  #         admin: 'Admin'
+  #       }
+  #       c.default_role = :user
+  #       c.before_scenaro 'setup user'
+  #     end
+  #     Lopata.shared_step 'setup user' do
+  #       setup { @user = User.create(role: current_role) if current_role }
+  #       cleanup :user
+  #     end
+  #     Lopata.define 'login' do
+  #       # will generate 2 scenarios, one for :user and one for :admin
+  #       as :user, :admin
+  #       action 'login'
+  #       # verify the user is logged in
+  #     end
+  #
   # @see Lopata::Configuration#role_descriptions
   # @see Lopata::Configuration#default_role
   module Role
     # To be included in Lopata::Scenario
     module Methods
+      # @return [Symbol, nil] user role for current scenario or nil, if scenario is running without user.
       def current_role
         metadata[:as]
       end
@@ -11,30 +35,50 @@ module Lopata
 
     # To be included in Lopata::ScenarioBuilder
     module DSL
+      # Enumerate the roles the scenario to be runned under.
+      # If not invoked the default role only will be used.
+      #
+      # The scenario should be set to use the role via before_scenario step using #current_role param.
+      #
+      # @param args [Array<Symbol>] list of roles the scenario to be runned with.
+      # @param block [Block] the block to calculate role from scenario metadata.
       def as(*args, &block)
         @roles = args.flatten
         @roles << Lopata::ScenarioBuilder::CalculatedValue.new(&block) if block_given?
         @role_options = nil
       end
 
+      # @private
       def role_options
         @role_options ||= build_role_options
       end
 
+      # Marks scenario to be runned without user.
+      #
+      # @example
+      #     Lopata.define 'scenario withou user' do
+      #       without_user
+      #       it 'does not define the user' do
+      #         expect(current_role).to be_nil
+      #       end
+      #     end
       def without_user
         @without_user = true
       end
 
+      # @private
       def build_role_options
         return [] unless roles
         [Lopata::ScenarioBuilder::Diagonal.new(:as, roles.map { |r| [Lopata.configuration.role_descriptions[r], r] })]
       end
 
+      # @private
       def roles
         return false if @without_user
         @roles ||= [Lopata.configuration.default_role].compact
       end
 
+      # @private
       def diagonals
         super + role_options
       end
@@ -43,4 +87,5 @@ module Lopata
 end
 
 Lopata::Scenario.include Lopata::Role::Methods
+# Prepend the module to overload #diagonals method
 Lopata::ScenarioBuilder.prepend Lopata::Role::DSL

data/lib/lopata/runner.rb

@@ -7,6 +7,7 @@ require_relative 'observers'
 require_relative 'condition'
 
 module Lopata
+  # @private
   class Runner < Thor
     desc 'test', 'Run tests'
     option :env, default: :qa, aliases: 'e'
@@ -14,13 +15,14 @@ module Lopata
     option :keep, type: :boolean, aliases: 'k'
     option :text, aliases: 't'
     def test(*args)
+      trap_interrupt
       configure_from_options
       Lopata::Loader.load_shared_steps
       Lopata::Loader.load_scenarios(*args)
       world = Lopata.world
-      world.start
+      world.notify_observers(:started, world)
       world.scenarios.each { |s| s.run }
-      world.finish
+      world.notify_observers(:finished, world)
     end
 
     default_task :test
@@ -51,6 +53,10 @@ module Lopata
         to_rerun = Lopata::Client.new.to_rerun
         Lopata.configuration.filters << -> (scenario) { to_rerun.include?(scenario.title) }
       end
+
+      def trap_interrupt
+        trap('INT') { exit!(1) }
+      end
     end
   end
 end

data/lib/lopata/scenario.rb

@@ -1,25 +1,41 @@
 require 'rspec/expectations'
 
+# Scenario runtime class.
+#
+# All the scenarios are running in context of separate Lopata::Scenario object.
+#
 class Lopata::Scenario
   include RSpec::Matchers
 
+  # @private
   attr_reader :execution
 
+  # @private
   def initialize(execution)
     @execution = execution
   end
 
   # Marks current step as pending
+  # @example
+  #     it 'pending step' do
+  #       pending
+  #       expect(1).to eq 2
+  #     end
+  #
+  # Pending steps wont be failed
   def pending(message = nil)
     execution.current_step.pending!(message)
   end
 
+  # @return [Hash] metadata available for current step
+  # @note The metadata keys also availalbe as methods (via method_missing)
   def metadata
     execution.metadata
   end
 
   private
 
+  # @private
   def method_missing(method, *args, &block)
     if execution.let_methods.include?(method)
       instance_exec(*args, &execution.let_methods[method])
@@ -30,10 +46,13 @@ class Lopata::Scenario
     end
   end
 
+  # @private
   def respond_to_missing?(method, *)
     execution.let_methods.include?(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
 

data/lib/lopata/scenario_builder.rb

@@ -1,19 +1,39 @@
+# Context for scenario creation.
 class Lopata::ScenarioBuilder
+  # @private
   attr_reader :title, :common_metadata, :options, :diagonals
+  # @private
   attr_accessor :shared_step, :group
 
+  # Defines one or more scenarios.
+  #
+  # @example
+  #     Lopata.define 'scenario' do
+  #       setup 'test user'
+  #       action 'login'
+  #       verify 'home page displayed'
+  #     end
+  #
+  # Given block will be calculated in context of the ScenarioBuilder
+  #
+  # @param title [String] scenario unique title
+  # @param metadata [Hash] metadata to be used within the scenario
+  # @param block [Block] the scenario definition
+  # @see Lopata.define
   def self.define(title, metadata = {}, &block)
     builder = new(title, metadata)
     builder.instance_exec &block
     builder.build
   end
 
+  # @private
   def initialize(title, metadata = {})
     @title, @common_metadata = title, metadata
     @diagonals = []
     @options = []
   end
 
+  # @private
   def build
     filters = Lopata.configuration.filters
     option_combinations.each do |option_set|
@@ -33,21 +53,104 @@ class Lopata::ScenarioBuilder
     end
   end
 
+  # @!group Defining variants
+
+  # Define option for the scenario.
+  #
+  # The scenario will be generated for all the options.
+  # If more then one option given, the scenarios for all options combinations will be generated.
+  #
+  # @param metadata_key [Symbol] the key to access option data via metadata.
+  # @param variants [Hash{String => Object}] variants for the option
+  #   Keys are titles of the variant, values are metadata values.
+  #
+  # @example
+  #   Lopata.define 'scenario' do
+  #     option :one, 'one' => 1, 'two' => 2
+  #     option :two, 'two' => 2, 'three' => 3
+  #     # will generate 4 scenarios:
+  #     # - 'scenario one two'
+  #     # - 'scenario one three'
+  #     # - 'scenario two two'
+  #     # - 'scenario two three'
+  #   end
+  #
+  # @see #diagonal
+  def option(metadata_key, variants)
+    @options << Option.new(metadata_key, variants)
+  end
+
+  # Define diagonal for the scenario.
+  #
+  # The scenario will be generated for all the variants of the diagonal.
+  # Each variant of diagonal will be selected for at least one scenario.
+  # It may be included in more then one scenario when other diagonal or option has more variants.
+  #
+  # @param metadata_key [Symbol] the key to access diagonal data via metadata.
+  # @param variants [Hash{String => Object}] variants for the diagonal.
+  #   Keys are titles of the variant, values are metadata values.
+  #
+  # @example
+  #   Lopata.define 'scenario' do
+  #     option :one, 'one' => 1, 'two' => 2
+  #     diagonal :two, 'two' => 2, 'three' => 3
+  #     diagonal :three, 'three' => 3, 'four' => 4, 'five' => 5
+  #     # will generate 3 scenarios:
+  #     # - 'scenario one two three'
+  #     # - 'scenario two three four'
+  #     # - 'scenario one two five'
+  #   end
+  #
+  # @see #option
+  def diagonal(metadata_key, variants)
+    @diagonals << Diagonal.new(metadata_key, variants)
+  end
+
+  # Define additional metadata for the scenario
+  #
+  # @example
+  #     Lopata.define 'scenario' do
+  #       metadata key: 'value'
+  #       it 'metadata available' do
+  #         expect(metadata[:key]).to eq 'value'
+  #       end
+  #     end
   def metadata(hash)
     raise 'metadata expected to be a Hash' unless hash.is_a?(Hash)
     @common_metadata ||= {}
     @common_metadata.merge! hash
   end
 
+  # Skip scenario for given variants combination
+  #
+  # @example
+  #     Lopata.define 'multiple options' do
+  #       option :one, 'one' => 1, 'two' => 2
+  #       option :two, 'two' => 2, 'three' => 3
+  #       skip_when { |opt| opt.metadata[:one] == opt.metadata[:two] }
+  #       it 'not equal' do
+  #         expect(one).to_not eq two
+  #       end
+  #     end
+  #
   def skip_when(&block)
     @skip_when = block
   end
 
+  # @private
   def skip?(option_set)
     @skip_when && @skip_when.call(option_set)
   end
 
-  %i{ setup action it teardown verify context }.each do |name|
+  # @!endgroup
+
+  # @!group Defining Steps
+
+  # @private
+  # @macro [attach] define_step_method
+  #   @!scope instance
+  #   @method $1
+  def self.define_step_method(name)
     name_if = "%s_if" % name
     name_unless = "%s_unless" % name
     define_method name, ->(*args, **metadata, &block) { add_step(name, *args, metadata: metadata, &block) }
@@ -59,6 +162,124 @@ class Lopata::ScenarioBuilder
     }
   end
 
+  # Define setup step.
+  # @example
+  #   setup do
+  #   end
+  #
+  #   # setup from named shared step
+  #   setup 'create user'
+  #
+  #   # setup with both shared step and code block
+  #   setup 'create user' do
+  #     @user.update(admin: true)
+  #   end
+  #
+  # Setup step used for set test data.
+  # @overload setup(*steps, &block)
+  #   @param steps [Array<String, Symbol, Proc>] the steps to be runned as a part of setup.
+  #     String - name of shared step to be called.
+  #     Symbol - metadata key, referenced to shared step name.
+  #     Proc - in-place step implementation.
+  #   @param block [Block] The implementation of the step.
+  define_step_method :setup
+
+  # Define action step.
+  # @example
+  #   action do
+  #   end
+  #
+  #   # action from named shared step
+  #   action 'login'
+  #
+  #   # setup with both shared step and code block
+  #   action 'login', 'go dashboard' do
+  #     @user.update(admin: true)
+  #   end
+  #
+  # Action step is used for emulate user or external system action
+  #
+  # @overload action(*steps, &block)
+  #   @param steps [Array<String, Symbol, Proc>] the steps to be runned as a part of action.
+  #     String - name of shared step to be called.
+  #     Symbol - metadata key, referenced to shared step name.
+  #     Proc - in-place step implementation.
+  #   @param block [Block] The implementation of the step.
+  define_step_method :action
+
+  # Define teardown step.
+  # @example
+  #   setup { @user = User.create! }
+  #   teardown { @user.destroy }
+  # Teardown step will be called at the end of scenario running.
+  # But it suggested to be decared right after setup or action step which require teardown.
+  #
+  # @overload teardown(*steps, &block)
+  #   @param steps [Array<String, Symbol, Proc>] the steps to be runned as a part of teardown.
+  #     String - name of shared step to be called.
+  #     Symbol - metadata key, referenced to shared step name.
+  #     Proc - in-place step implementation.
+  #   @param block [Block] The implementation of the step.
+  define_step_method :teardown
+
+  # Define verify steps.
+  # @example
+  #   verify 'home page displayed' # call shared step.
+  # Usually for validation shared steps inclusion
+  #
+  # @overload verify(*steps, &block)
+  #   @param steps [Array<String, Symbol, Proc>] the steps to be runned as a part of verification.
+  #     String - name of shared step to be called.
+  #     Symbol - metadata key, referenced to shared step name.
+  #     Proc - in-place step implementation.
+  #   @param block [Block] The implementation of the step.
+  define_step_method :verify
+
+  # Define group of steps.
+  # The metadata for the group may be overriden
+  # @example
+  #   context 'the task', task: :created do
+  #     verify 'task setup'
+  #     it 'created' do
+  #       expect(metadata[:task]).to eq :created
+  #     end
+  #   end
+  # Teardown steps within group will be called at the end of the group, not scenario
+  # @overload context(title, **metadata, &block)
+  #   @param title [String] context title
+  #   @param metadata [Hash] the step additional metadata
+  #   @param block [Block] The implementation of the step.
+  define_step_method :context
+
+  # Define single validation step.
+  # @example
+  #   it 'works' do
+  #     expect(1).to eq 1
+  #   end
+  # @overload it(title, &block)
+  #   @param title [String] validation title
+  #   @param block [Block] The implementation of the step.
+  define_step_method :it
+
+  # Define runtime method for the scenario.
+  #
+  # @note
+  #   The method to be called via #method_missing, so it wont override already defined methods.
+  #
+  # @example
+  #   let(:square) { |num| num * num }
+  #   it 'calculated' do
+  #     expect(square(4)).to eq 16
+  #   end
+  def let(method_name, &block)
+    steps << Lopata::Step.new(:let) do
+      execution.let(method_name, &block)
+    end
+  end
+
+  # @!endgroup
+
+  # @private
   def add_step(method_name, *args, condition: nil, metadata: {}, &block)
     step_class =
       case method_name
@@ -71,10 +292,12 @@ class Lopata::ScenarioBuilder
     steps << step
   end
 
+  # @private
   def steps
     @steps ||= []
   end
 
+  # @private
   def steps_with_hooks
     s = []
     unless Lopata.configuration.before_scenario_steps.empty?
@@ -90,20 +313,7 @@ class Lopata::ScenarioBuilder
     s
   end
 
-  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)
-  end
-
-  def diagonal(metadata_key, variants)
-    @diagonals << Diagonal.new(metadata_key, variants)
-  end
-
+  # @private
   def option_combinations
     combinations = combine([OptionSet.new], options + diagonals)
     while !diagonals.all?(&:complete?)
@@ -112,6 +322,7 @@ class Lopata::ScenarioBuilder
     combinations.reject { |option_set| skip?(option_set) }
   end
 
+  # @private
   def combine(source_combinations, rest_options)
     return source_combinations if rest_options.empty?
     combinations = []
@@ -124,40 +335,50 @@ class Lopata::ScenarioBuilder
     combine(combinations, rest_options)
   end
 
+  # @private
   def world
     Lopata.world
   end
 
-  # Набор вариантов, собранный для одного теста
+  # Set of options for scenario
   class OptionSet
+    # @private
     attr_reader :variants
+
+    # @private
     def initialize(*variants)
       @variants = {}
       variants.compact.each { |v| self << v }
     end
 
+    # @private
     def +(other_set)
       self.class.new(*@variants.values).tap do |sum|
         other_set.each { |v| sum << v }
       end
     end
 
+    # @private
     def <<(variant)
       @variants[variant.key] = variant
     end
 
+    # @private
     def [](key)
       @variants[key]
     end
 
+    # @private
     def each(&block)
       @variants.values.each(&block)
     end
 
+    # @private
     def title
       @variants.values.map(&:title).compact.join(' ')
     end
 
+    # @return [Hash{Symbol => Object}] metadata for this option set
     def metadata
       @variants.values.inject({}) do |metadata, variant|
         metadata.merge(variant.metadata(self))
@@ -165,6 +386,7 @@ class Lopata::ScenarioBuilder
     end
   end
 
+  # @private
   class Variant
     attr_reader :key, :title, :value, :option
 
@@ -213,6 +435,7 @@ class Lopata::ScenarioBuilder
       end
   end
 
+  # @private
   class CalculatedValue
     def initialize(&block)
       @proc = block
@@ -223,6 +446,7 @@ class Lopata::ScenarioBuilder
     end
   end
 
+  # @private
   class Option
     attr_reader :variants, :key
     def initialize(key, variants)
@@ -258,6 +482,7 @@ class Lopata::ScenarioBuilder
     end
   end
 
+  # @private
   class Diagonal < Option
     def level_variants
       [next_variant]

data/lib/lopata/shared_step.rb

@@ -1,9 +1,11 @@
 module Lopata
+  # @private
   class SharedStep
     attr_reader :name, :block
 
     class NotFound < StandardError; end
 
+
     def self.register(name, &block)
       raise ArgumentError, "Comma is not allowed in shared step name: '%s'" % name if name =~ /,/
       registry[name] = new(name, &block)

data/lib/lopata/step.rb

@@ -1,4 +1,5 @@
 module Lopata
+  # @private
   class Step
     attr_reader :block, :args, :condition, :method_name, :shared_step
     # metadata overrien by the step.
@@ -26,7 +27,8 @@ module Lopata
     end
   end
 
-  # Used for action, setup, teardown
+  # @private
+  # Used for action, setup, teardown, verify
   class ActionStep < Step
     def execution_steps(scenario, groups: [])
       steps = []
@@ -66,6 +68,7 @@ module Lopata
     end
   end
 
+  # @private
   # Used for context
   class GroupStep < Step
 
@@ -94,6 +97,7 @@ module Lopata
     end
   end
 
+  #@private
   class StepExecution
     attr_reader :step, :status, :exception, :block, :pending_message, :groups
     extend Forwardable

data/lib/lopata/version.rb

@@ -1,5 +1,6 @@
 module Lopata
+  # @private
   module Version
-    STRING = '0.1.6'
+    STRING = '0.1.7'
   end
 end

data/lib/lopata/world.rb

@@ -1,21 +1,15 @@
+# Container for gobal non-configuration data
 class Lopata::World
+  # Scenarios are selected for current run
+  # @return [Array<Lopata::Scenario::Execution>]
   attr_reader :scenarios
 
+  # @private
   def initialize
     @scenarios = []
   end
 
-  def start
-    notify_observers(:started, self)
-  end
-
-  # Called at the end of test running.
-  #
-  # Notifies observers about testing finish
-  def finish
-    notify_observers(:finished, self)
-  end
-
+  # @private
   def notify_observers(event, context)
     observers.each do |observer|
       observer.send event, context

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lopata
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Alexey Volochnev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-01 00:00:00.000000000 Z
+date: 2020-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -87,6 +87,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - README.md
 - exe/lopata
 - lib/lopata.rb
@@ -137,5 +138,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: lopata-0.1.6
+summary: lopata-0.1.7
 test_files: []