lopata 0.1.13 → 0.1.17

data/lib/lopata/observers/web_logger.rb

@@ -1,131 +1,131 @@
-require 'httparty'
-require 'json'
-require_relative 'backtrace_formatter'
-
-module Lopata
-  module Observers
-    # @private
-    class WebLogger < BaseObserver
-      def started(world)
-        @client = Lopata::Client.new
-        @client.start(world.scenarios.count)
-        @finished = 0
-      end
-
-      def scenario_finished(scenario)
-        @finished += 1
-        @client.add_attempt(scenario, @finished)
-      end
-    end
-  end
-
-  # @private
-  PASSED = 0
-  # @private
-  FAILED = 1
-  # @private
-  PENDING = 2
-  # @private
-  SKIPPED = 5
-
-  # @private
-  class Client
-    include HTTParty
-
-    attr_reader :url, :project_code, :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, 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)
-      post("/tests/#{test}/attempts.json", body: request)
-    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)
-      request = {
-        test: {
-          project_code: project_code,
-          title: scenario.title,
-          scenario: scenario.title,
-          build_number: build_number
-        }
-      }
-      response = post("/tests.json", body: request)
-      JSON.parse(response.body)["id"]
-    end
-
-    def to_rerun
-      get_json("/projects/#{project_code}/builds/#{build_number}/suspects.json")
-    end
-
-    def to_full_rescan
-      to_rerun + get_json("/projects/#{project_code}/builds/#{build_number}/failures.json")
-    end
-
-    private
-
-    def get_json(path)
-      JSON.parse(self.class.get(path, base_uri: url).body)
-    end
-
-    def post(*args)
-      self.class.post(*with_base_uri(args))
-    end
-
-    def 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 backtrace_for(step)
-      msg = ''
-      if step.exception
-        msg = backtrace_formatter.format(step.exception.backtrace).join("\n")
-        msg << "\n"
-      end
-      msg
-    end
-
-    def backtrace_formatter
-      @backtrace_formatter ||= Lopata::Observers::BacktraceFormatter.new
-    end
-  end
+require 'httparty'
+require 'json'
+require_relative 'backtrace_formatter'
+
+module Lopata
+  module Observers
+    # @private
+    class WebLogger < BaseObserver
+      def started(world)
+        @client = Lopata::Client.new
+        @client.start(world.scenarios.count)
+        @finished = 0
+      end
+
+      def scenario_finished(scenario)
+        @finished += 1
+        @client.add_attempt(scenario, @finished)
+      end
+    end
+  end
+
+  # @private
+  PASSED = 0
+  # @private
+  FAILED = 1
+  # @private
+  PENDING = 2
+  # @private
+  SKIPPED = 5
+
+  # @private
+  class Client
+    include HTTParty
+
+    attr_reader :url, :project_code, :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, 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)
+      post("/tests/#{test}/attempts.json", body: request)
+    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)
+      request = {
+        test: {
+          project_code: project_code,
+          title: scenario.title,
+          scenario: scenario.title,
+          build_number: build_number
+        }
+      }
+      response = post("/tests.json", body: request)
+      JSON.parse(response.body)["id"]
+    end
+
+    def to_rerun
+      get_json("/projects/#{project_code}/builds/#{build_number}/suspects.json")
+    end
+
+    def to_full_rescan
+      to_rerun + get_json("/projects/#{project_code}/builds/#{build_number}/failures.json")
+    end
+
+    private
+
+    def get_json(path)
+      JSON.parse(self.class.get(path, base_uri: url).body)
+    end
+
+    def post(*args)
+      self.class.post(*with_base_uri(args))
+    end
+
+    def 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 backtrace_for(step)
+      msg = ''
+      if step.exception
+        msg = backtrace_formatter.format(step.exception.backtrace).join("\n")
+        msg << "\n"
+      end
+      msg
+    end
+
+    def backtrace_formatter
+      @backtrace_formatter ||= Lopata::Observers::BacktraceFormatter.new
+    end
+  end
 end

data/lib/lopata/observers.rb

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

data/lib/lopata/role.rb

@@ -1,110 +1,110 @@
-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?
-        @use_all_roles = true
-        @role_options = nil
-      end
-
-      # Enumerate the roles the scenario can be run.
-      #
-      # The scenario should be set to use the role via before_scenario step using #current_role param.
-      #
-      # Only first role will be used if scenario has no options or diagonales. Some first roles will be used if
-      # options or diagonales are declared, in order of appearence.
-      #
-      # Use this to describe possible roles, but not needed to run scenario with all of them in order to save time
-      # of running.
-      #
-      # @param args [Array<Symbol>] list of roles the scenario to be runned with.
-      def as_first(*args, &block)
-        @roles = args.flatten
-        @use_all_roles = false
-        @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
-        role_variants = roles.map { |r| [Lopata.configuration.role_descriptions[r], r] }
-        [Lopata::ScenarioBuilder::Diagonal.new(:as, role_variants, @use_all_roles)]
-      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
+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?
+        @use_all_roles = true
+        @role_options = nil
+      end
+
+      # Enumerate the roles the scenario can be run.
+      #
+      # The scenario should be set to use the role via before_scenario step using #current_role param.
+      #
+      # Only first role will be used if scenario has no options or diagonales. Some first roles will be used if
+      # options or diagonales are declared, in order of appearence.
+      #
+      # Use this to describe possible roles, but not needed to run scenario with all of them in order to save time
+      # of running.
+      #
+      # @param args [Array<Symbol>] list of roles the scenario to be runned with.
+      def as_first(*args, &block)
+        @roles = args.flatten
+        @use_all_roles = false
+        @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
+        role_variants = roles.map { |r| [Lopata.configuration.role_descriptions[r], r] }
+        [Lopata::ScenarioBuilder::Diagonal.new(:as, role_variants, @use_all_roles)]
+      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,67 +1,80 @@
-require 'thor'
-require_relative 'generators/app'
-require_relative 'world'
-require_relative 'loader'
-require_relative '../lopata'
-require_relative 'observers'
-require_relative 'condition'
-
-module Lopata
-  # @private
-  class Runner < Thor
-    desc 'test', 'Run tests'
-    option :env, default: :qa, aliases: 'e'
-    option :rerun, type: :boolean, aliases: 'r'
-    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.notify_observers(:started, world)
-      world.scenarios.each { |s| s.run }
-      world.notify_observers(:finished, world)
-    end
-
-    default_task :test
-
-    register Generators::App, :new, 'lopata new project-name', 'Init new lopata projects'
-
-    def self.exit_on_failure?
-      true
-    end
-
-    no_commands do
-      def configure_from_options
-        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.configuration.filters << -> (scenario) { scenario.title.include?(text) }
-      end
-
-      def add_rerun_filter
-        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
-
-unless ARGV.first == 'new'
-  eval File.binread('./Lopatafile') if File.exists?('./Lopatafile')
-end
-
+require 'thor'
+require_relative 'generators/app'
+require_relative 'world'
+require_relative 'loader'
+require_relative '../lopata'
+require_relative 'observers'
+require_relative 'condition'
+
+module Lopata
+  # @private
+  class Runner < Thor
+    desc 'test', 'Run tests'
+    option :env, default: :qa, aliases: 'e'
+    option :rerun, type: :boolean, aliases: 'r'
+    option :keep, type: :boolean, aliases: 'k'
+    option :text, aliases: 't'
+    option :list, type: :boolean, aliases: 'l'
+    def test(*args)
+      trap_interrupt
+      configure_from_options
+      Lopata::Loader.load_shared_steps
+      Lopata::Loader.load_scenarios(*args)
+      if options[:list]
+        list_scenarios
+      else
+        run_scenarios
+      end
+    end
+
+    default_task :test
+
+    register Generators::App, :new, 'lopata new project-name', 'Init new lopata projects'
+
+    def self.exit_on_failure?
+      true
+    end
+
+    no_commands do
+      def configure_from_options
+        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.configuration.filters << -> (scenario) { scenario.title.include?(text) }
+      end
+
+      def add_rerun_filter
+        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
+
+      def list_scenarios
+        Lopata.world.scenarios.each { |s| puts s.title }
+      end
+
+      def run_scenarios
+        world = Lopata.world
+        world.notify_observers(:started, world)
+        world.scenarios.each { |s| s.run }
+        world.notify_observers(:finished, world)
+      end
+    end
+  end
+end
+
+unless ARGV.first == 'new'
+  eval File.binread('./Lopatafile') if File.exists?('./Lopatafile')
+end
+