polytrix 0.1.2 → 0.1.3

data/lib/polytrix/challenge.rb

@@ -1,14 +1,11 @@
 require 'benchmark'
-require 'hashie/dash'
-require 'hashie/extensions/coercion'
-require 'hashie/extensions/indifferent_access'
 require 'polytrix/documentation/helpers/code_helper'
 
 module Polytrix
   class Challenge < Polytrix::Dash # rubocop:disable ClassLength
-    include Polytrix::Core::FileSystemHelper
+    include Polytrix::Util::FileSystem
     include Polytrix::Logging
-    include Polytrix::StringHelpers
+    include Polytrix::Util::String
     # View helpers
     include Polytrix::Documentation::Helpers::CodeHelper
 
@@ -17,28 +14,45 @@ module Polytrix
     coerce_key :implementor, Polytrix::Implementor
     property :suite, required: true
     property :vars, default: {}
+    # coerce_key :vars, Polytrix::Manifest::Environment
     property :source_file
     coerce_key :source_file, Pathname
     property :basedir
     coerce_key :basedir, Pathname
     property :challenge_runner, default: ChallengeRunner.create_runner
     property :result
-    # coerce_key :results, Array[ChallengeResult]
-    property :env_file
-    # coerce_key :vars, Polytrix::Manifest::Environment
-    property :plugin_data, default: {}
+    coerce_key :results, ChallengeResult
+    property :spy_data, default: {}
     property :verification_level, default: 0
 
+    KEYS_TO_PERSIST = [:result, :spy_data]
+
+    def initialize(hash)
+      super
+      refresh
+    end
+
     def state_file
       @state_file ||= StateFile.new(Dir.pwd, slug)
     end
 
+    def refresh
+      @state = state_file.read
+      KEYS_TO_PERSIST.each do |key|
+        public_send("#{key}=".to_sym, @state[key]) if @state[key]
+      end
+    end
+
+    def validators
+      Polytrix::ValidatorRegistry.validators_for self
+    end
+
     def logger
       implementor.logger
     end
 
     def slug
-      slugify("#{suite}-#{name}-#{implementor.name}")
+      slugify(suite, name, implementor.name)
     end
 
     def absolute_source_file
@@ -47,6 +61,18 @@ module Polytrix
       File.expand_path source_file, basedir
     end
 
+    def detect
+      transition_to :detect
+    end
+
+    def detect_action
+      perform_action(:detect, 'Detecting code sample') do
+        fail FeatureNotImplementedError, "Implementor #{name} has not been cloned" unless implementor.cloned?
+        fail FeatureNotImplementedError, name if source_file.nil?
+        fail FeatureNotImplementedError, name unless File.exist?(absolute_source_file)
+      end
+    end
+
     def exec
       transition_to :exec
     end
@@ -55,7 +81,7 @@ module Polytrix
       perform_action(:exec, 'Executing') do
         fail FeatureNotImplementedError, "Implementor #{name} has not been cloned" unless implementor.cloned?
         fail FeatureNotImplementedError, name if source_file.nil?
-        fail FeatureNotImplementedError, name unless File.exists?(absolute_source_file)
+        fail FeatureNotImplementedError, name unless File.exist?(absolute_source_file)
         self.result = challenge_runner.run_challenge self
       end
     end
@@ -68,7 +94,7 @@ module Polytrix
       transition_to :destroy
     end
 
-    def test(destroy_mode = :passing)
+    def test(_destroy_mode = :passing)
       elapsed = Benchmark.measure do
         banner "Cleaning up any prior instances of #{slug}"
         destroy
@@ -78,47 +104,34 @@ module Polytrix
       end
       info "Finished testing #{slug} #{Util.duration(elapsed.real)}."
       self
-    # ensure
+      # ensure
       # destroy if destroy_mode == :always
     end
 
-    def code2doc
-      if source_file.nil?
-        warn "No code sample available for #{slug}, no documentation will be generated."
-        return
-      end
-
-      display_file = relativize(absolute_source_file, Dir.pwd)
-      banner "Generating documentation for #{slug} from #{display_file}"
-      target_dir = Polytrix.configuration.documentation_dir
-      format = Polytrix.configuration.documentation_format
-      target_file_name = File.basename(source_file, File.extname(source_file)) + ".#{format}"
-      target_file = File.join(target_dir, target_file_name)
-      doc = Polytrix::DocumentationGenerator.new.code2doc(absolute_source_file)
-      FileUtils.mkdir_p File.dirname(target_file)
-      File.write(target_file, doc)
-      info "Documentated saved to #{target_file}"
-    rescue Polytrix::Documentation::CommentStyles::UnknownStyleError => e
-      abort "Unknown file extension: #{e.extension}, please use --lang to set the language manually"
-    end
-
     def destroy_action
       perform_action(:destroy, 'Destroying') do
         @state_file.destroy
         @state_file = nil
-        @validations = nil
         @state = {}
+        refresh
       end
     end
 
     def verify_action
       perform_action(:verify, 'Verifying') do
-        validators = Polytrix::ValidatorRegistry.validators_for self
         validators.each do |validator|
-          validator.validate(self)
-          validations << validator.description
+          validation = validator.validate(self)
+          status = case validation.result
+                   when :passed
+                     Polytrix::Color.colorize('✓ Passed', :green)
+                   when :failed
+                     Polytrix::Color.colorize('x Failed', :red)
+                     Polytrix.handle_validation_failure(validation.error)
+                   else
+                     Polytrix::Color.colorize(validation.result, :yellow)
+                   end
+          info format('%-50s %s', validator.description, status)
         end
-        @state['validations'] = validations
       end
     end
 
@@ -133,55 +146,124 @@ module Polytrix
     end
 
     def action(what, &block)
-      @state = state_file.read
+      @state ||= state_file.read
+      @state['last_attempted_action'] = what.to_s
       elapsed = Benchmark.measure do
         # synchronize_or_call(what, @state, &block)
         block.call(@state)
       end
-      @state['last_action'] = what.to_s
+      @state['last_completed_action'] = what.to_s
       elapsed
     rescue Polytrix::FeatureNotImplementedError => e
       raise e
     rescue ActionFailed => e
       log_failure(what, e)
-      fail(ChallengeFailure, failure_message(what) +
+      raise(ChallengeFailure, failure_message(what) +
         "  Please see .polytrix/logs/#{name}.log for more details",
-           e.backtrace)
+            e.backtrace)
     rescue Exception => e # rubocop:disable RescueException
       log_failure(what, e)
-      fail ActionFailed,
-           "Failed to complete ##{what} action: [#{e.message}]", e.backtrace
+      raise ActionFailed,
+            "Failed to complete ##{what} action: [#{e.message}]", e.backtrace
     ensure
+      KEYS_TO_PERSIST.each do |key|
+        @state[key] = public_send(key)
+      end
       state_file.write(@state) unless what == :destroy
     end
 
+    def failed?
+      last_attempted_action != last_completed_action
+    end
+
+    def skipped?
+      result.nil?
+    end
+
+    def sample?
+      !source_file.nil?
+    end
+
+    def status
+      status = last_attempted_action
+      failed? ? "#{status}_failed" : status
+    end
+
+    def status_description
+      case status
+      when 'clone' then 'Cloned'
+      when 'clone_failed' then 'Clone Failed'
+      when 'detect' then 'Sample Found'
+      when 'detect_failed', nil then '<Not Found>'
+      when 'bootstrap' then 'Bootstrapped'
+      when 'bootstrap_failed' then 'Bootstrap Failed'
+      when 'detect' then 'Detected'
+      when 'exec' then 'Executed'
+      when 'exec_failed' then 'Execution Failed'
+      when 'verify', 'verify_failed'
+        validator_count = validators.count
+        validation_count = validations.values.select { |v| v['result'] == :passed }.count
+        if validator_count == validation_count
+          "Fully Verified (#{validation_count} of #{validator_count})"
+        else
+          "Partially Verified (#{validation_count} of #{validator_count})"
+        end
+      # when 'verify_failed' then 'Verification Failed'
+      else "<Unknown (#{status})>"
+      end
+    end
+
+    def status_color
+      case status_description
+      when '<Not Found>' then :white
+      when 'Cloned' then :magenta
+      when 'Bootstrapped' then :magenta
+      when 'Sample Found' then :cyan
+      when 'Executed' then :blue
+      when /Verified/
+        if status_description =~ /Fully/
+          :green
+        else
+          :yellow
+        end
+      else :red
+      end
+    end
+
     # Returns the last successfully completed action state of the instance.
     #
     # @return [String] a named action which was last successfully completed
-    def last_action
-      state_file.read['last_action']
+    def last_attempted_action
+      state_file.read['last_attempted_action']
+    end
+
+    def last_completed_action
+      state_file.read['last_completed_action']
     end
 
     def validations
-      @validations ||= (state_file.read['validations'] || [])
+      return nil if result.nil?
+      result.validations
     end
 
     def transition_to(desired)
       transition_result = nil
       begin
-        FSM.actions(last_action, desired).each do |transition|
+        FSM.actions(last_completed_action, desired).each do |transition|
           transition_result = send("#{transition}_action")
         end
       rescue Polytrix::FeatureNotImplementedError
         warn("#{slug} is not implemented")
       rescue ActionFailed => e
-        error("#{slug} failed: #{e}")
-        fail(ChallengeFailure, e.message, e.backtrace)
+        # Need to use with_friendly_errors again somewhere, since errors don't bubble up
+        # without fast-fail?
+        Polytrix.handle_error(e)
+        raise(ChallengeFailure, e.message, e.backtrace)
       end
       transition_result
     end
 
-    def log_failure(what, e)
+    def log_failure(what, _e)
       return if logger.logdev.nil?
 
       logger.logdev.error(failure_message(what))
@@ -195,7 +277,7 @@ module Polytrix
     # @return [String] a failure message
     # @api private
     def failure_message(what)
-      "#{what.capitalize} failed on instance #{slug}."
+      "#{what.capitalize} failed for test #{slug}."
     end
 
     # The simplest finite state machine pseudo-implementation needed to manage
@@ -223,7 +305,7 @@ module Polytrix
         end
       end
 
-      TRANSITIONS = [:destroy, :exec, :verify]
+      TRANSITIONS = [:destroy, :detect, :exec, :verify]
 
       # Determines the index of a state in the state lifecycle vector. Woah.
       #

data/lib/polytrix/challenge_result.rb

@@ -1,6 +1,4 @@
 require 'hashie/dash'
-require 'hashie/extensions/coercion'
-require 'hashie/extensions/indifferent_access'
 require 'polytrix/documentation/helpers/code_helper'
 
 module Polytrix

data/lib/polytrix/challenge_runner.rb

@@ -2,44 +2,54 @@ require 'polytrix'
 require 'rbconfig'
 
 module Polytrix
-  module Runners
-    autoload :LinuxChallengeRunner, 'polytrix/runners/linux_challenge_runner'
-    autoload :WindowsChallengeRunner, 'polytrix/runners/windows_challenge_runner'
+  module Executors
+    autoload :LinuxChallengeRunner, 'polytrix/executors/linux_challenge_executor'
+    autoload :WindowsChallengeRunner, 'polytrix/executors/windows_challenge_executor'
   end
 
   class ChallengeRunner < Thor::Shell::Color
-    include Polytrix::Core::FileSystemHelper
-    include Polytrix::Runners::Executor
-
-    attr_accessor :env
+    include Polytrix::Util::FileSystem
+    include Executor
 
     def self.create_runner
       case RbConfig::CONFIG['host_os']
       when /mswin(\d+)|mingw/i
-        Runners::WindowsChallengeRunner.new
+        # TODO: Display warning that Windows support is experimental
+        Executors::WindowsChallengeRunner.new
       else
-        Runners::LinuxChallengeRunner.new
+        Executors::LinuxChallengeRunner.new
       end
     end
 
-    def run_command(command)
+    def run_command(command, opts = { cwd: Dir.pwd })
       if Polytrix.configuration.dry_run
-        puts "Would have run #{command}"
+        puts "Would have run #{command} with #{opts.inspect}"
       else
         say_status 'polytrix:execute', command
-        execute command
+        execute(command, opts)
       end
     end
 
-    def run_challenge(challenge)
-      middleware.call(challenge)
-      challenge.result
+    def run_challenge(challenge, spies = Polytrix::Spies)
+      source_file = challenge[:source_file].to_s
+      basedir = challenge[:basedir].to_s
+      command = challenge_command(source_file, basedir)
+      spies.observe(challenge) do
+        execution_result = run_command(command, cwd: basedir, env: environment_variables(challenge[:vars]))
+        challenge[:result] = Result.new(execution_result: execution_result, source_file: source_file)
+      end
+      challenge[:result]
     end
 
-    private
+    protected
 
-    def middleware
-      Polytrix.configuration.middleware
+    def environment_variables(test_vars)
+      global_vars = begin
+        Polytrix.manifest[:global_env].dup
+      rescue
+        {}
+      end
+      global_vars.merge(test_vars.dup)
     end
   end
 end

data/lib/polytrix/cli.rb

@@ -2,6 +2,7 @@ require 'thor'
 
 require 'polytrix'
 require 'polytrix/command'
+require 'polytrix/command/report'
 
 module Polytrix
   class CLI < Thor # rubocop:disable ClassLength
@@ -29,8 +30,6 @@ module Polytrix
         str_const = Thor::Util.camel_case(command)
         klass = ::Polytrix::Command.const_get(str_const)
         klass.new(args, options, command_options).call
-      rescue ArgumentError => e
-        abort e.message
       end
     end
 
@@ -44,17 +43,30 @@ module Polytrix
     # Constructs a new instance.
     def initialize(*args)
       super
+      Polytrix.logger = Polytrix.default_file_logger
       $stdout.sync = true
     end
 
+    def self.filter_options
+      method_option :failed,
+                    type: :boolean,
+                    desc: 'Only list tests that failed / passed'
+      method_option :skipped,
+                    type: :boolean,
+                    desc: 'Only list tests that were skipped / executed'
+      method_option :samples,
+                    type: :boolean,
+                    desc: 'Only list tests that have sample code / do not have sample code'
+    end
+
     desc 'list [INSTANCE|REGEXP|all]', 'Lists one or more scenarios'
-    method_option :bare,
-                  aliases: '-b',
-                  type: :boolean,
-                  desc: 'List the name of each scenario only, one per line'
     method_option :log_level,
                   aliases: '-l',
                   desc: 'Set the log level (debug, info, warn, error, fatal)'
+    method_option :format,
+                  desc: 'List output format',
+                  enum: %w(text markdown json yaml),
+                  default: 'text'
     method_option :manifest,
                   aliases: '-m',
                   desc: 'The Polytrix test manifest file location',
@@ -65,22 +77,26 @@ module Polytrix
                   default: 'tests/polytrix'
     method_option :solo,
                   desc: 'Enable solo mode - Polytrix will auto-configure a single implementor and its scenarios'
-                  # , default: 'polytrix.yml'
+    # , default: 'polytrix.yml'
     method_option :solo_glob,
                   desc: 'The globbing pattern to find code samples in solo mode'
+    method_option :source,
+                  type: :boolean,
+                  desc: 'Include source file in listing'
+    filter_options
     def list(*args)
       update_config!
       perform('list', 'list', args, options)
     end
 
-    desc 'report [INSTANCE|REGEXP|all]', 'Summary report for one or more scenarios'
-    method_option :bare,
-                  aliases: '-b',
-                  type: :boolean,
-                  desc: 'List the name of each scenario only, one per line'
+    desc 'show [INSTANCE|REGEXP|all]', 'Show detailed status for one or more scenarios'
     method_option :log_level,
                   aliases: '-l',
                   desc: 'Set the log level (debug, info, warn, error, fatal)'
+    method_option :format,
+                  desc: 'List output format',
+                  enum: %w(text markdown json yaml),
+                  default: 'text'
     method_option :manifest,
                   aliases: '-m',
                   desc: 'The Polytrix test manifest file location',
@@ -91,25 +107,28 @@ module Polytrix
                   default: 'tests/polytrix'
     method_option :solo,
                   desc: 'Enable solo mode - Polytrix will auto-configure a single implementor and its scenarios'
-                  # , default: 'polytrix.yml'
+    # , default: 'polytrix.yml'
     method_option :solo_glob,
                   desc: 'The globbing pattern to find code samples in solo mode'
-    def report(*args)
+    filter_options
+    def show(*args)
       update_config!
-      perform('report', 'report', args, options)
+      perform('show', 'show', args, options)
     end
 
     {
-      clone: "Change scenario state to cloned. " \
-                    "Clone the code sample from git",
-      bootstrap: "Change scenario state to bootstraped. " \
-                    "Running bootstrap scripts for the implementor",
-      exec: "Change instance state to executed. " \
-                    "Execute the code sample and capture the results.",
-      verify: "Change instance state to verified. " \
-                    "Assert that the captured results match the expectations for the scenario.",
-      destroy: "Change scenario state to destroyed. " \
-                   "Delete all information for one or more scenarios"
+      clone: 'Change scenario state to cloned. ' \
+                    'Clone the code sample from git',
+      bootstrap: 'Change scenario state to bootstraped. ' \
+                    'Running bootstrap scripts for the implementor',
+      detect: 'Find sample code that matches a test scenario. ' \
+                    'Attempts to locate a code sample with a filename that the test scenario name.',
+      exec: 'Change instance state to executed. ' \
+                    'Execute the code sample and capture the results.',
+      verify: 'Change instance state to verified. ' \
+                    'Assert that the captured results match the expectations for the scenario.',
+      destroy: 'Change scenario state to destroyed. ' \
+                   'Delete all information for one or more scenarios'
     }.each do |action, short_desc|
       desc(
         "#{action} [INSTANCE|REGEXP|all]",
@@ -146,7 +165,6 @@ module Polytrix
       define_method(action) do |*args|
         update_config!
         action_options = options.dup
-        action_options['on'] = :implementor if [:clone, :bootstrap].include? action
         perform(action, 'action', args, action_options)
       end
     end
@@ -179,7 +197,7 @@ module Polytrix
                   default: 'tests/polytrix'
     method_option :solo,
                   desc: 'Enable solo mode - Polytrix will auto-configure a single implementor and its scenarios'
-                  # , default: 'polytrix.yml'
+    # , default: 'polytrix.yml'
     method_option :solo_glob,
                   desc: 'The globbing pattern to find code samples in solo mode'
     def test(*args)
@@ -188,54 +206,20 @@ module Polytrix
       perform('test', 'test', args, action_options)
     end
 
-    desc 'code2doc [INSTANCE|REGEXP|all]',
-         'Generates documenation from sample code for one or more scenarios'
-    long_desc <<-DESC
-      This task will convert annotated sample code to documentation. Markdown or
-      reStructureText are supported.
-    DESC
-    method_option :log_level,
-                  aliases: '-l',
-                  desc: 'Set the log level (debug, info, warn, error, fatal)'
-    method_option :manifest,
-                  aliases: '-m',
-                  desc: 'The Polytrix test manifest file location',
-                  default: 'polytrix.yml'
-    method_option :solo,
-                  desc: 'Enable solo mode - Polytrix will auto-configure a single implementor and its scenarios'
-                  # , default: 'polytrix.yml'
-    method_option :solo_glob,
-                  desc: 'The globbing pattern to find code samples in solo mode'
-    method_option :format,
-                  aliases: '-f',
-                  enum: %w(md rst),
-                  default: 'md',
-                  desc: 'Target documentation format'
-    method_option :target_dir,
-                  aliases: '-d',
-                  default: 'docs/',
-                  desc: 'The target directory where documentation for generated documentation.'
-    def code2doc(*args)
-      update_config!
-      action_options = options.dup
-      perform('code2doc', 'action', args, action_options)
-    end
-
     desc 'version', "Print Polytrix's version information"
     def version
       puts "Polytrix version #{Polytrix::VERSION}"
     end
-    map %w[-v --version] => :version
+    map %w(-v --version) => :version
 
-    # register Polytrix::CLI::Report, "init",
-    #   "init", "Adds some configuration to your cookbook so Polytrix can rock"
-    # long_desc <<-D, :for => "init"
-    #   Init will add Test Polytrix support to an existing project for
-    #   convergence integration testing. A default .polytrix.yml file (which is
-    #   intended to be customized) is created in the project's root directory
-    #   and one or more gems will be added to the project's Gemfile.
+    desc 'report', 'Generate reports'
+    subcommand 'report', Polytrix::Command::Report
+    # register Polytrix::Command::Report, 'report',
+    #          'report', 'Generates a report'
+    # long_desc <<-D, for: 'report'
+    #   Polytrix will generate an HTML report.
     # D
-    # tasks["init"].options = Polytrix::CLI::Report.class_options
+    # tasks['report'].options = Polytrix::Command::Report.class_options
 
     private
 

data/lib/polytrix/color.rb

@@ -8,10 +8,10 @@ module Polytrix
       bright_cyan: 96, bright_white: 97
     }.freeze
 
-    COLORS = %w[
+    COLORS = %w(
       cyan yellow green magenta blue bright_cyan bright_yellow
       bright_green bright_magenta bright_blue
-    ].freeze
+    ).freeze
 
     # Returns an ansi escaped string representing a color control sequence.
     #

data/lib/polytrix/command/action.rb

@@ -5,15 +5,16 @@ module Polytrix
     class Action < Polytrix::Command::Base
       include RunAction
 
+      IMPLEMENTOR_ACTIONS = [:clone, :bootstrap] # These are run once per implementor, not per test
+
       # Invoke the command.
       def call
         banner "Starting Polytrix (v#{Polytrix::VERSION})"
         elapsed = Benchmark.measure do
           setup
-          tests = parse_subcommand(args.first)
+          tests = parse_subcommand(args.pop)
           implementors = tests.map(&:implementor).uniq
-          # Logging.mdc['command'] = action
-          if [:clone, :bootstrap].include? action # actions on implementors
+          if IMPLEMENTOR_ACTIONS.include? action # actions on implementors
             run_action(action, implementors)
           else # actions on tests
             run_action(action, tests)