marso 0.1.15089 → 0.1.29007

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9dd68ffdf94aa8dc6c18a66a1be55774e8aa2b4b
-  data.tar.gz: 07415303338d5c40520661aa865a656b171cb148
+  metadata.gz: 68643dc298346f9de6a9ab082f1a36186a233ee3
+  data.tar.gz: 95b856464d21e45e9c0e0739a888f6a145ab42d8
 SHA512:
-  metadata.gz: 1386739d560795b6bcc2e6e74a59030aa46e9eeacfe3951bc3d62fbb58b9b48da18ea7ba2e7cb0374c151e9699e04ccc8595725e2e2ce38115034e529dad03db
-  data.tar.gz: fab73a4f66f4856dc1f2500f0aeeb9693bd9240caa7f0ca12d9a8f6b35812635dff42fc7e7fabd4e88a006392f0277502fbff4917abc9a3c393dc9660b260f66
+  metadata.gz: 192be817ccbc445432761b2387d647d472cff3ac4742a5c3a3d41032f767200a71fde202c773ae9dc05e158539ee4cac102824195381eac975af69399f99a2ca
+  data.tar.gz: 7b42ebd3d40cad49f852e2fb2431c7ed8c27e79414ce1818979d50a1eda38096073737e8b8cf23908304668fe9f8d8b43d40c98110c3ce446fd2adb715ea519a

data/lib/marso.rb

@@ -1,5 +1,20 @@
 require "marso/version"
-require "marso/assert"
 require "marso/factories"
 require "marso/config"
-require "marso/scenario"
+require "marso/launcher"
+require "marso/domain/step/step"
+require "marso/domain/step/step_publish"
+require "marso/domain/scenario/scenario"
+require "marso/domain/scenario/scenario_publish"
+require "marso/domain/story/story"
+require "marso/domain/story/story_load"
+require "marso/domain/story/story_publish"
+require "marso/domain/feature/feature"
+require "marso/domain/feature/feature_load"
+require "marso/domain/feature/feature_publish"
+require "marso/helpers/texthelper"
+require "marso/helpers/statushelper"
+require "marso/helpers/componenthelper"
+require "marso/messages/errors"
+require "marso/validation/symbol"
+require "marso/toolbelt/fiberpiping"

data/lib/marso/config.rb

@@ -1,11 +1,11 @@
 module Marso
   class Config
     @@configuration={
-      # If true, the result of each step is output to the console in realtime.
-      # The consequence os setting that config to true is that steps
-      # may be harder to read together when multiple scenarios are executed
-      # paralell. Steps of different scenarios may indeed be intertwined in the
-      # console
+      # If true, the result of each step is output to the console in realtime
+      # rather than waiting for the entire scenario to finish and then display
+      # all the steps all at once. Setting that config to true may make reading
+      # the output harder when multiple scenarios are executed in paralell.
+      # Steps of different scenarios may indeed be intertwined in the console
       :realtime_step_stdout => false,
 
       # If true, all steps of the same scenario defined after a broken step(i.e.

data/lib/marso/domain/feature/feature.rb

@@ -0,0 +1,124 @@
+require 'securerandom'
+require_relative 'feature_load'
+require_relative 'feature_publish'
+require_relative '../../helpers/statushelper'
+
+module Marso
+
+  class Feature
+    include FeatureLoad
+    include FeaturePublish
+
+    attr_reader :id, :description, :status, :ctx, :stories, :scenario_contexts,
+    :rootpath, :header, :text, :tree_position, :color_theme
+
+    # description (optional): Hash defined as follow
+    #   :id => Arbitrary number or string. Default is randomly generated
+    #          (hex string (length 8))
+    #   :name => Story's name
+    #   :in_order_to => String that describes the fundamental story's business
+    #                   value
+    #   :as_a => String that describes the user(s)
+    #   :i => String that describes the feature that could deliver the story's
+    #         business value(e.g. I want ... or I should ...)
+    #   :stories => Array of all the stories that are part of that feature
+    #   :scenario_contexts => Array of all the scenario contexts that are part
+    #                         of that feature
+    #   :rootpath => Path to the folder that contain this current feature's file
+    #                as well as its associated 'scenarios' and 'stories' folder
+    #   :status => Can only be set if both :scenario_contexts and :stories are
+    #              empty. Otherwise, it will be overidden by the status of
+    #              either :scenario_contexts or :stories
+    def initialize(description={}, ctx={})
+      validate_arguments(description, ctx)
+
+      @description = description.clone
+      @ctx = ctx.clone
+
+      @description[:scenario_contexts] = [] if description[:scenario_contexts].nil?
+      @description[:stories] = [] if description[:stories].nil?
+      @description[:id] = SecureRandom.hex(4) if description[:id].nil?
+      @description[:rootpath] = File.dirname(caller[0]) if description[:rootpath].nil?
+
+      @rootpath = @description[:rootpath]
+      @id = @description[:id]
+      @scenario_contexts = @description[:scenario_contexts]
+      @stories = @description[:stories]
+
+      if @scenario_contexts.empty? && @stories.empty? && !@description[:status].nil?
+        @status = @description[:status]
+      else
+        @status = Marso.item_with_stronger_status(@stories, @scenario_contexts).status
+      end
+
+      @tree_position = 0
+      @header = get_header(@id, @status, @description)
+      @color_theme = get_color_theme(@status)
+      @text = get_text(@header, @description)
+    end
+
+    # Returns the combination of the feature's scenario contexts and the
+    # scenario contexts under each feature's stories
+    def all_scenario_contexts
+      @scenario_contexts | self.stories_scenario_contexts
+    end
+
+    # Returns all the scenario contexts under each feature's stories
+    def stories_scenario_contexts
+      @stories.map { |s| s.scenario_contexts }.flatten
+    end
+
+    private
+
+      def validate_arguments(description, ctx)
+        raise ArgumentError, "Argument 'description' cannot be nil" if description.nil?
+        raise ArgumentError, "Argument 'description' must be a Hash" unless description.is_a?(Hash)
+        raise ArgumentError, "Argument 'ctx' must be a Hash" unless ctx.is_a?(Hash)
+        unless description[:scenario_contexts].nil?
+          unless description[:scenario_contexts].empty?
+            raise ArgumentError, "Argument 'description[:scenario_contexts]' must be an Array" unless description[:scenario_contexts].is_a?(Array)
+            offender = description[:scenario_contexts].detect { |x| !x.is_a?(Marso::ScenarioContext) }.class
+            raise ArgumentError, "One value inside 'description[:scenario_contexts]' is of type #{offender}. The only type allowed is Marso::ScenarioContext" unless offender == NilClass
+          end
+        end
+      end
+
+      def get_header(id, status, description)
+        header = "Feature #{id}: #{description[:name]}"
+
+        case status
+        when :passed
+          return "#{header}: PASSED"
+        when :none
+          return header
+        when :failed_no_component
+          return "#{header}: FAILED - No scenarios or stories found"
+        else
+          return "#{header}: FAILED"
+        end
+      end
+
+      def get_color_theme(status)
+        case status
+        when :passed
+          :green
+        when :failed_no_component
+          :red
+        when :failed
+          :red
+        when :error
+          :red
+        else
+          :light_yellow
+        end
+      end
+
+      def get_text(header, description)
+        feat_parts = [header]
+        feat_parts << "In order to #{description[:in_order_to]}" if description.key?(:in_order_to)
+        feat_parts << "As a #{description[:as_a]}" if description.key?(:as_a)
+        feat_parts << "I #{description[:i]}" if description.key?(:i)
+        feat_parts.join("\n")
+      end
+  end
+end

data/lib/marso/domain/feature/feature_load.rb

@@ -0,0 +1,60 @@
+require_relative '../../helpers/componenthelper'
+
+module Marso
+  module FeatureLoad
+
+    # Load feature's components based on the following mode:
+    # => :none
+    # => :stories
+    # => :stories_with_scenarios
+    # => :scenario_contexts
+    # => :all
+    def load(mode)
+      case mode
+      when :none
+          return self
+      when :stories
+        return load_stories
+      when :stories_with_scenarios
+        return load_stories :with_scenarios
+      when :scenario_contexts
+        return load_scenario_contexts
+      when :all
+        return self.load(:stories_with_scenarios).load(:scenario_contexts)
+      else
+        raise ArgumentError, "Mode #{mode} is not supported. Use one of the following: :stories, :scenario_contexts, :all"
+      end
+    end
+
+    private
+
+      def load_scenario_contexts
+        new_ctx = @ctx.clone
+        new_ctx[:feature_id] = @id
+        file_path_pattern = File.join(@rootpath, 'scenarios/*.rb')
+
+        scenario_ctxs = Marso.load_components(:scenario_context, file_path_pattern, new_ctx)
+
+        new_description = @description.clone
+        new_description[:scenario_contexts] = scenario_ctxs
+        return Feature.new(new_description, new_ctx)
+      end
+
+      # include_mode (optional):
+      # => :none - (Default) Only display the story's description
+      # => :with_scenarios - Display the story's description as well as all its
+      #                      scenarios' description
+      def load_stories(include_mode=:none)
+        new_ctx = @ctx.clone
+        new_ctx[:feature_id] = @id
+        file_path_pattern = File.join(@rootpath, 'stories/*/*.rb')
+
+        stories = Marso.load_components(:story, file_path_pattern, new_ctx)
+          .map { |s| include_mode == :with_scenarios ? s.load(:scenario_contexts) : s}
+
+        new_description = @description.clone
+        new_description[:stories] = stories
+        return Feature.new(new_description, new_ctx)
+      end
+  end
+end

data/lib/marso/domain/feature/feature_publish.rb

@@ -0,0 +1,73 @@
+require 'colorize'
+require_relative '../../helpers/texthelper'
+
+module Marso
+  module FeaturePublish
+    include TextHelper
+
+    def colorized_text
+      self.text.colorize(self.color_theme)
+    end
+
+    # include_mode => Symbol that defines what should be included in the
+    #                 feature's description. Possible values are:
+    #   :none - (Default) Only display the feature's description
+    #   :with_stories - Display the feature description as well as all its
+    #                   stories' description
+    #   :with_stories_scenarios - Display the feature description as well
+    #                             as all its stories' description
+    #                             (including their scenarios)
+    #   :with_scenarios - Display the feature description as well as all its
+    #                     scenarios' description
+    #   :with_all - Display the feature description as well as both all its
+    #               stories(including their scenarios) and scenarios descriptions
+    def indented_colorized_details(include_mode=:none)
+
+      get_scenario_ctxs_text_a = lambda { |f|
+        f.scenario_contexts.map { |scn| scn.indented_colorized_text }
+      }
+
+      get_stories_text_a = lambda { |f|
+        f.stories.map { |s| s.indented_colorized_text }
+      }
+
+      get_stories_scenarios_text_a = lambda { |f|
+        f.stories.map { |s|
+          [s.indented_colorized_text]
+            .concat(s.scenario_contexts # add scenarios' text under each story
+              .map { |scn| scn.indented_colorized_text })
+            .join("\n") }
+      }
+
+      get_indented_colored_text = lambda { |f|
+        case include_mode
+        when :none
+          f.indented_colorized_text
+        when :with_scenarios
+          [f.indented_colorized_text]
+            .concat(get_scenario_ctxs_text_a.call(f)) # add scenarios' text under each feat
+            .join("\n")
+        when :with_stories
+          [f.indented_colorized_text]
+            .concat(get_stories_text_a.call(f)) # add stories' text under each feat
+            .join("\n")
+        when :with_stories_scenarios
+          [f.indented_colorized_text]
+            .concat(get_stories_scenarios_text_a.call(f)) # add stories' text under each feat
+            .join("\n")
+        when :with_all
+          [f.indented_colorized_text]
+            .concat(get_scenario_ctxs_text_a.call(f)) # add scenarios' text under each feat
+            .concat(get_stories_scenarios_text_a.call(f)) # add stories' text under each feat
+            .join("\n")
+        else
+          raise ArgumentError, ":#{include_mode} is not a valid argument. " +
+          "Please choose one of the following:\n" +
+          "- #{[:none, :with_scenarios, :with_stories, :with_stories_scenarios, :with_all].join('\n- ')}"
+        end
+      }
+
+      return get_indented_colored_text.call(self)
+    end
+  end
+end

data/lib/marso/domain/scenario/scenario.rb

@@ -0,0 +1,279 @@
+require 'colorize'
+require 'securerandom'
+require_relative '../../config'
+require_relative 'scenario_publish'
+
+module Marso
+
+  class ScenarioContext
+    attr_reader :id, :before_run, :get_scenario, :after_run, :ctx, :status,
+    :description, :story_id, :feature_id
+
+    def initialize(description, ctx)
+      validate_arguments(description, ctx)
+
+      @description = description.clone
+
+      @description[:id] = SecureRandom.hex(4) if description[:id].nil?
+      @description[:status] = :none if description[:status].nil?
+      @ctx=ctx.clone
+
+      @id = @description[:id]
+      @before_run=@description[:before_run]
+      @get_scenario=@description[:get_scenario]
+      @after_run=@description[:after_run]
+      @status=@description[:status]
+
+      @story_id = ctx[:story_id]
+      @feature_id = ctx[:feature_id]
+    end
+
+    def run
+      @before_run.call(@description[:id], @ctx) unless @before_run.nil?
+      s = @get_scenario.call(@id, @ctx)
+      runned_scenario = s.run
+      @after_run.call(@id, @ctx) unless @after_run.nil?
+
+      updated_description = @description.clone
+      updated_description[:get_scenario] = proc { runned_scenario }
+      updated_description[:status] = runned_scenario.status
+
+      return ScenarioContext.new(updated_description, @ctx)
+    end
+
+    def puts_scenario
+      s = @get_scenario.call(@id, @ctx)
+      s.puts_description
+    end
+
+    def indented_colorized_text
+      s = @get_scenario.call(@id, @ctx)
+      s.indented_colorized_text
+    end
+
+    private
+      def validate_arguments(description, ctx)
+        raise ArgumentError, "Argument 'ctx' must be a Hash" unless ctx.is_a?(Hash)
+        raise ArgumentError, "Argument 'description' cannot be nil" if description.nil?
+        raise ArgumentError, "Argument 'description' must define a :get_scenario key that points to a closure that returns a Marso::Scenario object" if description[:get_scenario].nil?
+      end
+  end
+
+  class Scenario
+    include ScenarioPublish
+
+    ISSUES_LIST = [:error, :failed, :cancelled]
+
+    @@color_options=nil
+    @@color_options_size=0
+
+    attr_reader :name, :steps, :id, :status, :color_theme,
+    :cancel_steps_upon_issues, :realtime_step_stdout, :ctx, :story_id,
+    :feature_id, :header, :tree_position
+
+    # description: Hash defined as follow
+    #   :id => Arbitrary number or string. Default is randomly generated
+    #          (hex string (length 8))
+    #   :name => Scenario's name
+    #   :steps => array of Step objects
+    #   :color_theme => color from gem 'colorize'(e.g. :blue). That allows
+    #                   to visually group all steps from the same scenario.
+    #                   Default is randomly choosen from the available set
+    #   :cancel_steps_upon_issues => Boolean. If true, all steps defined after
+    #                                a broken step(i.e. step in status :failed,
+    #                                :error, or :cancelled) will not be
+    #                                executed, and will all be set so their
+    #                                status is :cancelled.
+    #
+    #                                If defined, it overrides the
+    #                                Config.cancel_steps_upon_issues setting.
+    #   :realtime_step_stdout => Boolean. If true, the result of each step is
+    #                            output to the console in realtime rather than
+    #                            waiting for the entire scenario to finish and
+    #                            then display all the steps all at once. Setting
+    #                            that config to true may make reading the output
+    #                            harder when multiple scenarios are executed in
+    #                            paralell.Steps of different scenarios may
+    #                            indeed be intertwined in the console.
+    #
+    #                            If defined, it overrides the
+    #                            Config.realtime_step_stdout setting.
+    def initialize(description, ctx={})
+      validate_arguments(description, ctx)
+
+      if @@color_options.nil?
+        @@color_options = String.colors
+        @@color_options_size = @@color_options.size
+      end
+
+      @name = description[:name]
+      @ctx = ctx.clone
+
+      @tree_position = 0
+      @tree_position+=1 unless ctx[:story_id].nil?
+      @tree_position+=1 unless ctx[:feature_id].nil?
+
+      @story_id = ctx[:story_id]
+      @feature_id = ctx[:feature_id]
+
+      @id =
+        description.key?(:id) ?
+        description[:id] :
+        SecureRandom.hex(4)
+
+      @status =
+        description.key?(:status) ?
+        description[:status] :
+        :none
+
+      @color_theme =
+        description.key?(:color_theme) ?
+        description[:color_theme] :
+        @@color_options[rand(@@color_options_size)]
+
+      @steps =
+        description.key?(:steps) ?
+        description[:steps].map { |s| Step.new(s.text, @id, @color_theme, s.status, &s.block) } :
+        []
+
+      @header = get_header(@id, @ctx)
+
+      @cancel_steps_upon_issues =
+        description.key?(:cancel_steps_upon_issues) ?
+        description[:cancel_steps_upon_issues] :
+        Marso::Config.get(:cancel_steps_upon_issues)
+
+      @realtime_step_stdout =
+        description.key?(:realtime_step_stdout) ?
+        description[:realtime_step_stdout] :
+        Marso::Config.get(:realtime_step_stdout)
+    end
+
+    def given(assumption_text, *args, &block)
+      return add_step(:given, assumption_text, *args, &block)
+    end
+
+    def and(assumption_text, *args, &block)
+      return add_step(:and, assumption_text, *args, &block)
+    end
+
+    def when(assumption_text, *args, &block)
+      return add_step(:when, assumption_text, *args, &block)
+    end
+
+    def then(assumption_text, *args, &block)
+      return add_step(:then, assumption_text, *args, &block)
+    end
+
+    def but(assumption_text, *args, &block)
+      return add_step(:but, assumption_text, *args, &block)
+    end
+
+    # include_id will prepend the scenario id to the step's description.
+    # This can be useful in the case where each step is being output to the
+    # console in realtime. In that situation multiple steps from multiple
+    # scenarios may be intertwined if they are executed concurently. Without
+    # the scenario id, it may be difficult to identify which step belongs to
+    # which scenario
+    def text(include_id=false)
+      return
+        "{@header}: #{name}\n" +
+        (@steps.any? ? @steps.map { |s| s.text(include_id) }.join("\n") : "")
+    end
+
+    def run
+      previous_step_status = nil
+      scenario_status = :passed
+      no_issues = true
+
+      processed_steps = @steps.map { |s|
+        runned_step = run_step(s, previous_step_status)
+
+        print_indented(runned_step.print_description) if @realtime_step_stdout
+
+        previous_step_status = runned_step.status
+
+        if no_issues
+          case previous_step_status
+          when :error
+            no_issues = false
+            scenario_status = :error
+          when :failed
+            no_issues = false
+            scenario_status = :failed
+          when :cancelled
+            no_issues = false
+            scenario_status = :failed
+          end
+        end
+
+        runned_step
+      }
+
+      updated_scenario = Scenario.new(
+        {
+          :id => @id,
+          :name => @name,
+          :steps => processed_steps,
+          :status => scenario_status,
+          :color_theme => @color_theme
+        },
+        @ctx)
+
+      return updated_scenario
+    end
+
+    private
+
+      def validate_arguments(description, ctx)
+          raise ArgumentError, "Argument 'description' must be a Hash" unless description.is_a?(Hash)
+          raise ArgumentError, "Argument 'ctx' must be a Hash" unless ctx.is_a?(Hash)
+      end
+
+      def add_step(step_type, assumption_text, *args, &block)
+        body_msg = nil
+        status = :none
+        step_name = step_type.to_s.capitalize
+
+        begin
+          body_msg = "#{step_name} " + assumption_text % args
+        rescue Exception => e
+          status = :error
+          body_msg =
+            "#{assumption_text}: ERROR\n" +
+            "args: #{args.nil? ? '' : args.join(',')}\n" +
+            "#{e.message}\n" +
+            "#{e.backtrace}"
+        end
+
+        new_step_series = @steps | [Step.new(body_msg, @id, color_theme, status, &block)]
+
+        return Scenario.new(
+          {
+            :id => @id,
+            :name => @name,
+            :steps => new_step_series,
+            :status => @status,
+            :color_theme => @color_theme
+          },
+          @ctx)
+      end
+
+      def run_step(step, previous_step_status)
+        if ISSUES_LIST.include?(previous_step_status) && @cancel_steps_upon_issues
+          cancelled_step = Step.new(step.text, @id, @color_theme, :cancelled, &step.block)
+          return cancelled_step.execute
+        else
+          return step.run
+        end
+      end
+
+      def get_header(id, ctx)
+        header = []
+        header << "Feature #{ctx[:feature_id]}" unless ctx[:feature_id].nil?
+        header << "Story #{ctx[:story_id]}" unless ctx[:story_id].nil?
+        header << "Scenario #{id}"
+        header.join(" - ")
+      end
+  end
+end