polytrix 0.1.0.pre → 0.1.0

data/features/fixtures/spec/polytrix_spec.rb

@@ -1,10 +1,7 @@
 require 'polytrix/rspec'
 
 Polytrix.configure do |polytrix|
-  Dir['sdks/*'].each do |sdk|
-    polytrix.implementor sdk
-  end
-  polytrix.test_manifest = 'polytrix_tests.yml'
+  polytrix.manifest = 'polytrix.yml'
 end
 Polytrix.bootstrap
 Polytrix.load_tests

data/features/solo.feature

@@ -0,0 +1,12 @@
+Feature: Solo execution
+
+  Polytrix has a --solo mode for use if there is only a single implementor. It will infer some implementor settings and test scenarios so you can use Polytrix with minimal configuration.
+
+  In --solo mode, Polytrix will:
+    - Configure a single implementor based in the current working directory
+    - Auto-detect test scenarios based on file glob pattern
+
+  Scenario: Cloning all SDKs
+    Given the ruby SDK
+    When I run `bundle exec polytrix exec --solo=sdks/ruby`
+    Then the output should contain "Executing challenges-hello_world-ruby"

data/features/states.feature

@@ -0,0 +1,40 @@
+Feature: States
+
+  Scenario: Initial state
+    Given the ruby SDK
+    And the java SDK
+    And the python SDK
+    And the hello_world polytrix config
+    And the standard rspec setup
+    When I run `bundle exec polytrix list`
+    Then the output should contain:
+    """
+    Suite  Scenario     Implementor  Status
+    Katas  hello world  ruby         <Not Found>
+    Katas  hello world  java         <Not Found>
+    Katas  hello world  python       <Not Found>
+    """
+
+  @no-clobber
+  Scenario: State after execution
+    Given I run `bundle exec polytrix exec python`
+    When I run `bundle exec polytrix list`
+    Then the output should contain:
+    """
+    Suite  Scenario     Implementor  Status
+    Katas  hello world  ruby         <Not Found>
+    Katas  hello world  java         <Not Found>
+    Katas  hello world  python       Executed
+    """
+
+  @no-clobber
+  Scenario: State after verification
+    Given I run `bundle exec polytrix verify ruby`
+    When I run `bundle exec polytrix list`
+    Then the output should contain:
+    """
+    Suite  Scenario     Implementor  Status
+    Katas  hello world  ruby         Verified (Level 0)
+    Katas  hello world  java         <Not Found>
+    Katas  hello world  python       Executed
+    """

data/features/step_definitions/sdk_steps.rb

@@ -1,12 +1,22 @@
+require 'yaml'
+
 Given(/^the (\w+) SDK$/) do |sdk|
   FileUtils.mkdir_p "#{current_dir}/sdks"
   FileUtils.cp_r "samples/sdks/#{sdk}", "#{current_dir}/sdks"
 end
 
 Given(/^the (\w+) polytrix config$/) do |config|
-  FileUtils.cp_r "features/fixtures/configs/#{config}.yml", "#{current_dir}/polytrix_tests.yml"
+  FileUtils.cp_r "features/fixtures/configs/#{config}.yml", "#{current_dir}/polytrix.yml"
 end
 
 Given(/^the standard rspec setup$/) do
   FileUtils.cp_r 'features/fixtures/spec/', "#{current_dir}/"
 end
+
+Then(/^the file "(.*?)" should contain yaml matching:$/) do |file, content|
+  in_current_dir do
+    actual_content = YAML.load(File.read(file))
+    expected_content = YAML.load(content)
+    expect(actual_content).to eq(expected_content)
+  end
+end

data/features/support/env.rb

@@ -2,7 +2,8 @@ require 'simplecov'
 SimpleCov.start
 
 require 'aruba/cucumber'
+require 'aruba/jruby'
 
 Before do
-  @aruba_timeout_seconds = 20
+  @aruba_timeout_seconds = RUBY_PLATFORM == 'java' ? 60 : 30
 end

data/lib/polytrix/challenge.rb

@@ -1,18 +1,20 @@
+require 'benchmark'
 require 'hashie/dash'
 require 'hashie/extensions/coercion'
 require 'hashie/extensions/indifferent_access'
 require 'polytrix/documentation/helpers/code_helper'
 
 module Polytrix
-  class Challenge < Hashie::Dash
-    include Hashie::Extensions::Coercion
-
-    # View heleprs
+  class Challenge < Polytrix::Dash # rubocop:disable ClassLength
+    include Polytrix::Core::FileSystemHelper
+    include Polytrix::Logging
+    include Polytrix::StringHelpers
+    # View helpers
     include Polytrix::Documentation::Helpers::CodeHelper
 
     property :name
-    property :description
     property :implementor
+    coerce_key :implementor, Polytrix::Implementor
     property :suite, required: true
     property :vars, default: {}
     property :source_file
@@ -21,20 +23,216 @@ module Polytrix
     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: {}
+    property :verification_level, default: 0
+
+    def state_file
+      @state_file ||= StateFile.new(Dir.pwd, slug)
+    end
+
+    def logger
+      implementor.logger
+    end
+
+    def slug
+      slugify("#{suite}-#{name}-#{implementor.name}")
+    end
+
+    def absolute_source_file
+      return nil if source_file.nil?
+
+      File.expand_path source_file, basedir
+    end
+
+    def exec
+      transition_to :exec
+    end
+
+    def exec_action
+      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)
+        self.result = challenge_runner.run_challenge self
+      end
+    end
+
+    def verify
+      transition_to :verify
+    end
+
+    def destroy
+      transition_to :destroy
+    end
+
+    def test(destroy_mode = :passing)
+      elapsed = Benchmark.measure do
+        banner "Cleaning up any prior instances of #{slug}"
+        destroy
+        banner "Testing #{slug}"
+        verify
+        # destroy if destroy_mode == :passing
+      end
+      info "Finished testing #{slug} #{Util.duration(elapsed.real)}."
+      self
+    # 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
 
-    def run
-      @result = challenge_runner.run_challenge self
+      display_file = relativize(absolute_source_file, Dir.pwd)
+      banner "Generating documentation from #{display_file}"
+      target_dir = Polytrix.configuration.documentation_dir
+      format = Polytrix.configuration.documentation_format
+      # language = options[:lang]
+      language = '.rb'
+      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, language)
+      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 validate
-      run unless @result
-      # validators = Polytrix::ValidatorRegistry.validators_for self
-      # validators.each do |validator|
-      #   validator.validate self
-      # end
+    def destroy_action
+      perform_action(:destroy, 'Destroying') do
+        # @state_file.destroy
+        # @state_file = nil
+      end
+      @state_file.destroy
+      @state_file = nil
+    end
+
+    def verify_action
+      perform_action(:verify, 'Verifying') do
+        validators = Polytrix::ValidatorRegistry.validators_for self
+        validators.each do |validator|
+          validator.validate self
+        end
+      end
+    end
+
+    def perform_action(verb, output_verb)
+      banner "#{output_verb} #{slug}..."
+      elapsed = action(verb) { yield }
+      # elapsed = action(verb) { |state| driver.public_send(verb, state) }
+      info("Finished #{output_verb.downcase} #{slug}" \
+        " #{Util.duration(elapsed.real)}.")
+      # yield if block_given?
+      self
+    end
+
+    def action(what, &block)
+      state = state_file.read
+      elapsed = Benchmark.measure do
+        # synchronize_or_call(what, state, &block)
+        block.call(state)
+      end
+      state['last_action'] = what.to_s
+      elapsed
+    rescue Polytrix::FeatureNotImplementedError => e
+      raise e
+    rescue ActionFailed => e
+      log_failure(what, e)
+      fail(ChallengeFailure, failure_message(what) +
+        "  Please see .polytrix/logs/#{name}.log for more details",
+           e.backtrace)
+    rescue Exception => e # rubocop:disable RescueException
+      log_failure(what, e)
+      fail ActionFailed,
+           "Failed to complete ##{what} action: [#{e.message}]", e.backtrace
+    ensure
+      state_file.write(state)
+    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']
+    end
+
+    def transition_to(desired)
+      transition_result = nil
+      begin
+        FSM.actions(last_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)
+      end
+      transition_result
+    end
+
+    def log_failure(what, e)
+      return if logger.logdev.nil?
+
+      logger.logdev.error(failure_message(what))
+      # Error.formatted_trace(e).each { |line| logger.logdev.error(line) }
+    end
+
+    # Returns a string explaining what action failed, at a high level. Used
+    # for displaying to end user.
+    #
+    # @param what [String] an action
+    # @return [String] a failure message
+    # @api private
+    def failure_message(what)
+      "#{what.capitalize} failed on instance #{slug}."
+    end
+
+    # The simplest finite state machine pseudo-implementation needed to manage
+    # an Instance.
+    #
+    # @api private
+    class FSM
+      # Returns an Array of all transitions to bring an Instance from its last
+      # reported transistioned state into the desired transitioned state.
+      #
+      # @param last [String,Symbol,nil] the last known transitioned state of
+      #   the Instance, defaulting to `nil` (for unknown or no history)
+      # @param desired [String,Symbol] the desired transitioned state for the
+      #   Instance
+      # @return [Array<Symbol>] an Array of transition actions to perform
+      # @api private
+      def self.actions(last = nil, desired)
+        last_index = index(last)
+        desired_index = index(desired)
+
+        if last_index == desired_index || last_index > desired_index
+          Array(TRANSITIONS[desired_index])
+        else
+          TRANSITIONS.slice(last_index + 1, desired_index - last_index)
+        end
+      end
+
+      TRANSITIONS = [:destroy, :exec, :verify]
+
+      # Determines the index of a state in the state lifecycle vector. Woah.
+      #
+      # @param transition [Symbol,#to_sym] a state
+      # @param [Integer] the index position
+      # @api private
+      def self.index(transition)
+        if transition.nil?
+          0
+        else
+          TRANSITIONS.find_index { |t| t == transition.to_sym }
+        end
+      end
     end
   end
 end

data/lib/polytrix/challenge_result.rb

@@ -0,0 +1,9 @@
+require 'hashie/dash'
+require 'hashie/extensions/coercion'
+require 'hashie/extensions/indifferent_access'
+require 'polytrix/documentation/helpers/code_helper'
+
+module Polytrix
+  class ChallengeResult < Polytrix::Dash
+  end
+end

data/lib/polytrix/challenge_runner.rb

@@ -1,5 +1,4 @@
 require 'polytrix'
-require 'mixlib/shellout'
 require 'rbconfig'
 
 module Polytrix
@@ -10,7 +9,7 @@ module Polytrix
 
   class ChallengeRunner < Thor::Shell::Color
     include Polytrix::Core::FileSystemHelper
-    include Polytrix::Executor
+    include Polytrix::Runners::Executor
 
     def self.create_runner
       case RbConfig::CONFIG['host_os']
@@ -21,14 +20,6 @@ module Polytrix
       end
     end
 
-    def editor_enabled?
-      !challenge_editor.nil?
-    end
-
-    def challenge_editor
-      ENV['CHALLENGE_EDITOR']
-    end
-
     def run_command(command)
       if Polytrix.configuration.dry_run
         puts "Would have run #{command}"
@@ -39,8 +30,10 @@ module Polytrix
     end
 
     def run_challenge(challenge)
+      # Logging.mdc['implementor'] = "\033[35m#{challenge.implementor.name}\033[0m"
+      # Logging.mdc['scenario'] = "\033[32m#{challenge.name}\033[0m"
       middleware.call(challenge)
-      challenge
+      challenge.result
     end
 
     private

data/lib/polytrix/challenges.rb

@@ -0,0 +1,16 @@
+module Polytrix
+  class Challenges < Hash
+    def get(regex)
+      _, v = find do |k, _|
+        regex.match k
+      end
+      v
+    end
+
+    def get_all(regex)
+      select do |k, _|
+        regex.match k
+      end.values
+    end
+  end
+end

data/lib/polytrix/cli/report.rb

@@ -48,10 +48,6 @@ module Polytrix
 
       protected
 
-      def matrix_data
-        @matrix ||= Polytrix::Manifest.new(YAML.load(Polytrix.merge_results(Dir['reports/test_report*.yaml'])))
-      end
-
       def load_results
         result_stats = Hash.new do |hash, sdk|
           hash[sdk] = { passed: 0, failed: 0, pending: 0, skipped: 0 }