lopata 0.1.1 → 0.1.6

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/observers/backtrace_formatter.rb

@@ -0,0 +1,103 @@
+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 /\.rvm/ ]
+        patterns.map! { |s| Regexp.new(s.gsub("/", File::SEPARATOR)) }
+
+        @exclusion_patterns = [Regexp.union(*patterns)]
+        @inclusion_patterns = []
+
+        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?
+
+        backtrace.map { |l| backtrace_line(l) }.compact.
+          tap do |filtered|
+            if filtered.empty?
+              filtered.concat backtrace
+              filtered << ""
+              filtered << "  Showing full backtrace because every line was filtered out."
+            end
+          end
+      end
+
+
+      # Extracts error message from excetion
+      #
+      # @param exeption [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)
+        msg = ''
+        msg << "\n#{source_line}\n" if source_line
+        msg << "#{exception.class.name}: " unless exception.class.name =~ /RSpec/
+        msg << exception.message if exception.message
+        msg << "\n#{backtrace.join("\n")}\n" if include_backtrace
+        msg
+      end
+
+      def extract_source_line(backtrace_line)
+        file_and_line_number = backtrace_line.match(/(.+?):(\d+)(|:\d+)/)
+        return nil unless file_and_line_number
+        file_path, line_number = file_and_line_number[1..2]
+        return nil unless File.exist?(file_path)
+        lines = File.read(file_path).split("\n")
+        lines[line_number.to_i - 1]
+      end
+
+      def backtrace_line(line)
+        relative_path(line) unless exclude?(line)
+      end
+
+      def exclude?(line)
+        matches?(exclusion_patterns, line) && !matches?(inclusion_patterns, line)
+      end
+
+      private
+
+      def matches?(patterns, line)
+        patterns.any? { |p| line =~ p }
+      end
+
+      # Matches strings either at the beginning of the input or prefixed with a
+      # whitespace, containing the current path, either postfixed with the
+      # separator, or at the end of the string. Match groups are the character
+      # before and the character after the string if any.
+      #
+      # http://rubular.com/r/fT0gmX6VJX
+      # http://rubular.com/r/duOrD4i3wb
+      # http://rubular.com/r/sbAMHFrOx1
+      def relative_path_regex
+        @relative_path_regex ||= /(\A|\s)#{File.expand_path('.')}(#{File::SEPARATOR}|\s|\Z)/
+      end
+
+      # @param line [String] current code line
+      # @return [String] relative path to line
+      def relative_path(line)
+        line = line.sub(relative_path_regex, "\\1.\\2".freeze)
+        line = line.sub(/\A([^:]+:\d+)$/, '\\1'.freeze)
+        return nil if line == '-e:1'.freeze
+        line
+      rescue SecurityError
+        nil
+      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 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

@@ -1,35 +1,45 @@
+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
 
-      def step_finished(step)
-        @failed_steps << step if step.failed?
-      end
-
-      def scenario_started(scenario)
-        @failed_steps = []
-      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)
 
-        @failed_steps.each do |step|
-          if step.exception
-            puts step.exception.message
-            puts step.exception.backtrace.join("\n")
-            puts
+        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
@@ -38,25 +48,52 @@ module Lopata
         case status
         when :failed then red(text)
         when :passed then green(text)
+        when :skipped then cyan(text)
+        when :pending then yellow(text)
         else text
         end
       end
 
-      def red(text)
-        wrap(text, 31)
+      {
+        red: 31,
+        green: 32,
+        cyan: 36,
+        yellow: 33,
+        bold: 1,
+      }.each do |color, code|
+        define_method(color) do |text|
+          wrap(text, code)
+        end
       end
 
-      def green(text)
-        wrap(text, 32)
+      def wrap(text, code)
+        "\e[#{code}m#{text}\e[0m"
       end
 
-      def bold(text)
-        wrap(text, 1)
+      def backtrace_formatter
+        @backtrace_formatter ||= Lopata::Observers::BacktraceFormatter.new
       end
 
-      def wrap(text, code)
-        "\e[#{code}m#{text}\e[0m"
+      def status_marker(status)
+        case status
+        when :failed then "[!]"
+        when :skipped then "[-]"
+        when :pending then "[?]"
+        else "[+]"
+        end
+      end
+
+      # Adds indent to text
+      # @param cols [Number] number of spaces to be added
+      # @param text [String] text to add indent
+      # @return [String] text with indent
+      def indent(cols, text)
+        text.split("\n").map { |line| " " * cols + line }.join("\n")
+      end
+
+      def statuses
+        @statuses ||= {}
       end
     end
   end
-end
+end

data/lib/lopata/observers/web_logger.rb

@@ -1,49 +1,20 @@
 require 'httparty'
 require 'json'
+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)
-        if scenario.failed?
-          backtrace = backtrace_for(scenario)
-          @client.add_attempt(scenario, Lopata::FAILED, error_message_for(scenario), backtrace)
-        else
-          @client.add_attempt(scenario, Lopata::PASSED)
-        end
-      end
-
-      # def example_pending(notification)
-      #   example = notification.example
-      #   @client.add_attempt(example, Lopata::PENDING, example.execution_result.pending_message)
-      # end
-
-      private
-
-      def error_message_for(scenario)
-        exception = scenario.steps.map(&:exception).compact.last
-        msg = ''
-        if exception
-          msg << "#{exception.class.name}: " unless exception.class.name =~ /RSpec/
-          msg << "#{exception.message.to_s}" if exception.message
-        end
-        (msg.length == 0) ? 'Empty message' : msg
-      end
-
-      def backtrace_for(scenario)
-        exception = scenario.steps.map(&:exception).compact.last
-        msg = ''
-        if exception
-          msg = exception.backtrace.join("\n")
-          msg << "\n"
-        end
-        msg
+        @finished += 1
+        @client.add_attempt(scenario, @finished)
       end
     end
   end
@@ -51,28 +22,41 @@ module Lopata
   PASSED = 0
   FAILED = 1
   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, status, msg = nil, backtrace = nil)
+    def add_attempt(scenario, finished)
+      status = scenario.failed? ? Lopata::FAILED : Lopata::PASSED
+      steps = scenario.steps.map { |s| step_hash(s) }
+      request = { status: status, steps: steps, launch: { id: @launch_id, finished: finished } }
       test = test_id(scenario)
-      request = { status: status}
-      request[:message] = msg if msg
-      request[:backtrace] = backtrace if backtrace
       post("/tests/#{test}/attempts.json", body: request)
-      inc_finished
+    end
+
+    def step_hash(step)
+      hash = { status: step.status, title: step.title }
+      if step.failed?
+        hash[:message] = error_message_for(step)
+        hash[:backtrace] = backtrace_for(step)
+      end
+      hash
     end
 
     def test_id(scenario)
@@ -98,32 +82,46 @@ 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 with_base_uri(args = [])
+      if args.last.is_a? Hash
+        args.last[:base_uri] = url
+      else
+        args << { base_uri: url }
+      end
+      args
+    end
+
+    def error_message_for(step)
+      if step.exception
+        backtrace_formatter.error_message(step.exception)
+      else
+        'Empty error message'
+      end
     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 backtrace_for(step)
+      msg = ''
+      if step.exception
+        msg = backtrace_formatter.format(step.exception.backtrace).join("\n")
+        msg << "\n"
       end
+      msg
     end
 
-    def project_code
-      Lopata::Config.lopata_code
+    def backtrace_formatter
+      @backtrace_formatter ||= Lopata::Observers::BacktraceFormatter.new
     end
   end
 end