lopata 0.1.2 → 0.1.7

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
@@ -11,10 +13,8 @@ module Lopata
       def create_root_files
         template 'Lopatafile', "#{name}/Lopatafile"
         template 'Gemfile', "#{name}/Gemfile"
-        template '.rspec', "#{name}/.rspec"
         template 'config/environments/qa.yml', "#{name}/config/environments/qa.yml"
         template 'config/initializers/capybara.rb', "#{name}/config/initializers/capybara.rb"
-        template 'spec/spec_helper.rb', "#{name}/spec/spec_helper.rb"
       end
 
       def init_dirs

data/lib/lopata/generators/templates/Gemfile

@@ -1,7 +1,5 @@
 source 'https://rubygems.org'
 gem 'selenium-webdriver'
-gem 'rspec', :require => 'spec'
-gem 'rake'
 gem 'activerecord', '~> 6.0.2'
 gem 'capybara', '~> 3.11.1'
 gem 'thor'

data/lib/lopata/generators/templates/config/environments/qa.yml

@@ -1,5 +1,4 @@
 url: http://yourapp.com
-name: QA
 # db:
 #   adapter: postgresql
 #   host: localhost

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

@@ -1,11 +1,15 @@
 module Lopata
   module Observers
+    # @private
     # Based on RSpec::Core::BacktraceFormatter
+    #
+    # Provides ability to format backtrace and find source code by file and line number.
     class BacktraceFormatter
+      # @private
       attr_accessor :exclusion_patterns, :inclusion_patterns
 
       def initialize
-        patterns = %w[ /lib\d*/ruby/ bin/ exe/lopata /lib/bundler/ /exe/bundle: ]
+        patterns = %w[ /lib\d*/ruby/ bin/ exe/lopata /lib/bundler/ /exe/bundle /\.rvm/ ]
         patterns.map! { |s| Regexp.new(s.gsub("/", File::SEPARATOR)) }
 
         @exclusion_patterns = [Regexp.union(*patterns)]
@@ -14,6 +18,10 @@ module Lopata
         inclusion_patterns << Regexp.new(Dir.getwd)
       end
 
+      # Filter backtrace.
+      #
+      # @param backtrace [Array<String>] exception backtrace
+      # @return [Array<String>] backtrace lines except ruby libraries, gems and executable files.
       def format(backtrace)
         return [] unless backtrace
         return backtrace if backtrace.empty?
@@ -28,6 +36,12 @@ module Lopata
           end
       end
 
+
+      # Extracts error message from excetion
+      #
+      # @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)
         backtrace = format(exception.backtrace)
         source_line = extract_source_line(backtrace.first)
@@ -86,4 +100,4 @@ module Lopata
       end
     end
   end
-end
+end

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 scenario [Lopata::Scenario::Execution]
       def scenario_started(scenario)
       end
 
+      # Called after single scenario execution.
+      # @param scenario [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,50 +4,54 @@ 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
 
+  # @private
   PASSED = 0
+  # @private
   FAILED = 1
+  # @private
   PENDING = 2
+  # @private
   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 +86,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,91 @@
+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
+    end
+
+    # 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
+    end
+  end
+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

@@ -1,6 +1,5 @@
 require 'thor'
 require_relative 'generators/app'
-require_relative 'config'
 require_relative 'world'
 require_relative 'loader'
 require_relative '../lopata'
@@ -8,24 +7,22 @@ require_relative 'observers'
 require_relative 'condition'
 
 module Lopata
+  # @private
   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)
+      trap_interrupt
       configure_from_options
       Lopata::Loader.load_shared_steps
       Lopata::Loader.load_scenarios(*args)
-      world = Lopata::Config.world
-      world.start
+      world = Lopata.world
+      world.notify_observers(:started, world)
       world.scenarios.each { |s| s.run }
-      world.finish
+      world.notify_observers(:finished, world)
     end
 
     default_task :test
@@ -38,27 +35,27 @@ 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
+
+      def trap_interrupt
+        trap('INT') { exit!(1) }
       end
     end
   end