polytrix 0.1.0.pre → 0.1.0

data/lib/polytrix/cli.rb

@@ -1,158 +1,250 @@
-require 'polytrix'
 require 'thor'
 
-module Polytrix
-  module CLI
-    autoload :Add, 'polytrix/cli/add'
-    autoload :Report, 'polytrix/cli/report'
-
-    class Base < Thor
-      include Polytrix::Core::FileSystemHelper
-
-      def self.config_options
-        # I had trouble with class_option and subclasses...
-        method_option :manifest, type: 'string', default: 'polytrix_tests.yml', desc: 'The Polytrix test manifest file'
-        method_option :config, type: 'string', default: 'polytrix.rb', desc: 'The Polytrix config file'
-      end
-
-      def self.log_options
-        method_option :quiet, type: :boolean, default: false, desc: 'Do not print log messages'
-      end
-
-      def self.doc_options
-        method_option :target_dir, type: :string, default: 'docs'
-        method_option :lang, enum: Polytrix::Documentation::CommentStyles::COMMENT_STYLES.keys, desc: 'Source language (auto-detected if not specified)'
-        method_option :format, enum: %w(md rst), default: 'md'
-      end
+require 'polytrix'
+require 'polytrix/command'
 
-      def self.sdk_options
-        method_option :sdk, type: 'string', desc: 'An implementor name or directory', default: '.'
+module Polytrix
+  class CLI < Thor # rubocop:disable ClassLength
+    # Common module to load and invoke a CLI-implementation agnostic command.
+    module PerformCommand
+      # Perform a scenario subcommand.
+      #
+      # @param task [String] action to take, usually corresponding to the
+      #   subcommand name
+      # @param command [String] command class to create and invoke]
+      # @param args [Array] remainder arguments from processed ARGV
+      #   (default: `nil`)
+      # @param additional_options [Hash] additional configuration needed to
+      #   set up the command class (default: `{}`)
+      def perform(task, command, args = nil, additional_options = {})
+        require "polytrix/command/#{command}"
+
+        command_options = {
+          action: task,
+          help: -> { help(task) },
+          test_dir: @test_dir,
+          shell: shell
+        }.merge(additional_options)
+
+        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
 
-      protected
-
-      def find_sdks(sdks)
-        sdks.map do |sdk|
-          implementor = Polytrix.implementors.find { |i| i.name == sdk }
-          abort "SDK #{sdk} not found" if implementor.nil?
-          implementor
-        end
-      end
+    include Logging
+    include PerformCommand
 
-      def pick_implementor(sdk)
-        Polytrix.implementors.find { |i| i.name == sdk } || Polytrix.configuration.implementor(sdk)
-      end
+    # The maximum number of concurrent instances that can run--which is a bit
+    # high
+    MAX_CONCURRENCY = 9999
 
-      def debug(msg)
-        say("polytrix::debug: #{msg}", :cyan) if debugging?
-      end
+    # Constructs a new instance.
+    def initialize(*args)
+      super
+      $stdout.sync = true
+      # Polytrix.logger = Polytrix.default_file_logger
+    end
 
-      def debugging?
-        !ENV['POLYTRIX_DEBUG'].nil?
-      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 :manifest,
+                  aliases: '-m',
+                  desc: 'The Polytrix test manifest file location',
+                  default: 'polytrix.yml'
+    method_option :test_dir,
+                  aliases: '-t',
+                  desc: 'The Polytrix test directory',
+                  default: 'tests/polytrix'
+    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'
+    def list(*args)
+      update_config!
+      perform('list', 'list', args, options)
+    end
 
-      def setup
-        manifest_file = File.expand_path options[:manifest]
-        config_file = File.expand_path options[:config]
-        if File.exists? manifest_file
-          debug "Loading manifest file: #{manifest_file}"
-          Polytrix.configuration.test_manifest = manifest_file if File.exists? manifest_file
-        end
-        if File.exists? config_file
-          debug "Loading Polytrix config: #{config_file}"
-          require_relative config_file
-        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"
+    }.each do |action, short_desc|
+      desc(
+        "#{action} [INSTANCE|REGEXP|all]",
+        short_desc
+      )
+      long_desc <<-DESC
+        The scenario states are in order: cloned, bootstrapped, executed, verified.
+        Change one or more scenarios from the current state to the #{action} state. Actions for all
+        intermediate states will be executed.
+      DESC
+      method_option :concurrency,
+                    aliases: '-c',
+                    type: :numeric,
+                    lazy_default: MAX_CONCURRENCY,
+                    desc: <<-DESC.gsub(/^\s+/, '').gsub(/\n/, ' ')
+          Run a #{action} against all matching instances concurrently. Only N
+          instances will run at the same time if a number is given.
+        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 :test_dir,
+                    aliases: '-t',
+                    desc: 'The Polytrix test directory',
+                    default: 'tests/polytrix'
+      method_option :solo,
+                    desc: 'Enable solo mode - Polytrix will auto-configure a single implementor and its scenarios'
+      method_option :solo_glob,
+                    desc: 'The globbing pattern to find code samples in solo mode'
+      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
 
-    class Main < Base
-      include Polytrix::Documentation::Helpers::CodeHelper
-
-      # register Add, :add, 'add', 'Add implementors or code samples'
-      # register Report, :report, 'report', 'Generate test reports'
-      desc 'add', 'Add implementors or code samples'
-      subcommand 'add', Add
-
-      desc 'report', 'Generate test reports'
-      subcommand 'report', Report
-
-      desc 'code2doc FILES', 'Converts annotated code to Markdown or reStructuredText'
-      doc_options
-      def code2doc(*files)
-        if files.empty?
-          help('code2doc')
-          abort 'No FILES were specified, check usage above'
-        end
-
-        files.each do |file|
-          target_file_name = File.basename(file, File.extname(file)) + ".#{options[:format]}"
-          target_file = File.join(options[:target_dir], target_file_name)
-          say_status 'polytrix:code2doc', "Converting #{file} to #{target_file}", !quiet?
-          doc = Polytrix::DocumentationGenerator.new.code2doc(file, options[:lang])
-          FileUtils.mkdir_p File.dirname(target_file)
-          File.write(target_file, doc)
-        end
-      rescue Polytrix::Documentation::CommentStyles::UnknownStyleError => e
-        abort "Unknown file extension: #{e.extension}, please use --lang to set the language manually"
-      end
+    desc 'test [INSTANCE|REGEXP|all]',
+         'Test (clone, bootstrap, exec, and verify) one or more scenarios'
+    long_desc <<-DESC
+      The scenario states are in order: cloned, bootstrapped, executed, verified.
+      Test changes the state of one or more scenarios executes
+      the actions for each state up to verify.
+    DESC
+    method_option :concurrency,
+                  aliases: '-c',
+                  type: :numeric,
+                  lazy_default: MAX_CONCURRENCY,
+                  desc: <<-DESC.gsub(/^\s+/, '').gsub(/\n/, ' ')
+        Run a test against all matching instances concurrently. Only N
+        instances will run at the same time if a number is given.
+      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 :test_dir,
+                  aliases: '-t',
+                  desc: 'The Polytrix test directory',
+                  default: 'tests/polytrix'
+    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'
+    def test(*args)
+      update_config!
+      action_options = options.dup
+      perform('test', 'test', args, action_options)
+    end
 
-      desc 'exec', 'Executes code sample(s), using the SDK settings if provided'
-      method_option :code2doc, type: :boolean, desc: 'Convert successfully executed code samples to documentation using the code2doc command'
-      doc_options
-      sdk_options
-      config_options
-      def exec(*files)
-        setup
-        if files.empty?
-          help('exec')
-          abort 'No FILES were specified, check usage above'
-        end
-
-        exec_options = {
-          # default_implementor: pick_implementor(options[:sdk])
-        }
-
-        files.each do | file |
-          say_status 'polytrix:exec', "Running #{file}..."
-          results = Polytrix.exec(file, exec_options)
-          display_results results
-          code2doc(file) if options[:code2doc]
-        end
-      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 'bootstrap [SDKs]', 'Bootstraps the SDK by installing dependencies'
-      config_options
-      def bootstrap(*sdks)
-        setup
-        Polytrix.bootstrap(*sdks)
-      rescue ArgumentError => e
-        abort e.message
-      end
+    desc 'version', "Print Polytrix's version information"
+    def version
+      puts "Polytrix version #{Polytrix::VERSION}"
+    end
+    map %w[-v --version] => :version
+
+    # register Polytrix::Generator::Init, "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.
+    # D
+    # tasks["init"].options = Polytrix::Generator::Init.class_options
+
+    private
+
+    # Ensure the any failing commands exit non-zero.
+    #
+    # @return [true] you die always on failure
+    # @api private
+    def self.exit_on_failure?
+      true
+    end
 
-      desc 'test [SDKs]', 'Runs and tests the code samples'
-      method_option :rspec_options, format: 'string', desc: 'Extra options to pass to rspec'
-      config_options
-      def test(*sdks)
-        setup
-        implementors = find_sdks(sdks)
-        Polytrix.configuration.rspec_options = options[:rspec_options]
-        Polytrix.run_tests(implementors)
-      end
+    # @return [Logger] the common logger
+    # @api private
+    def logger
+      Polytrix.logger
+    end
 
-      protected
+    # Update and finalize options for logging, concurrency, and other concerns.
+    #
+    # @api private
+    def update_config!
+    end
 
-      def quiet?
-        options[:quiet] || false
-      end
+    # If auto_init option is active, invoke the init generator.
+    #
+    # @api private
+    def ensure_initialized
+    end
 
-      def display_results(challenge)
-        short_name = challenge.name
-        exit_code = challenge.result.execution_result.exitstatus
-        color = exit_code == 0 ? :green : :red
-        stderr = challenge.result.execution_result.stderr
-        say_status "polytrix:exec[#{short_name}][stderr]", stderr, !quiet? unless stderr.empty?
-        say_status "polytrix:exec[#{short_name}]", "Finished with exec code: #{challenge.result.execution_result.exitstatus}", color unless quiet?
-      end
+    def duration(total)
+      total = 0 if total.nil?
+      minutes = (total / 60).to_i
+      seconds = (total - (minutes * 60))
+      format('(%dm%.2fs)', minutes, seconds)
     end
   end
 end

data/lib/polytrix/color.rb

@@ -0,0 +1,40 @@
+module Polytrix
+  module Color
+    ANSI = {
+      reset: 0, black: 30, red: 31, green: 32, yellow: 33,
+      blue: 34, magenta: 35, cyan: 36, white: 37,
+      bright_black: 90, bright_red: 91, bright_green: 92,
+      bright_yellow: 93, bright_blue: 94, bright_magenta: 95,
+      bright_cyan: 96, bright_white: 97
+    }.freeze
+
+    COLORS = %w[
+      cyan yellow green magenta blue bright_cyan bright_yellow
+      bright_green bright_magenta bright_blue
+    ].freeze
+
+    # Returns an ansi escaped string representing a color control sequence.
+    #
+    # @param name [Symbol] a valid color representation, taken from
+    #   Polytrix::Color::ANSI
+    # @return [String] an ansi escaped string if the color is valid and an
+    #   empty string otherwise
+    def self.escape(name)
+      return '' if name.nil?
+      return '' unless ANSI[name]
+      "\e[#{ANSI[name]}m"
+    end
+
+    # Returns a colorized ansi escaped string with the given color.
+    #
+    # @param str [String] a string to colorize
+    # @param name [Symbol] a valid color representation, taken from
+    #   Polytrix::Color::ANSI
+    # @return [String] an ansi escaped string if the color is valid and an
+    #   unescaped string otherwise
+    def self.colorize(str, name)
+      color = escape(name)
+      color.empty? ? str : "#{color}#{str}#{escape(:reset)}"
+    end
+  end
+end

data/lib/polytrix/command/action.rb

@@ -0,0 +1,26 @@
+require 'benchmark'
+
+module Polytrix
+  module Command
+    class Action < Polytrix::Command::Base
+      include RunAction
+
+      # Invoke the command.
+      def call
+        banner "Starting Polytrix (v#{Polytrix::VERSION})"
+        elapsed = Benchmark.measure do
+          setup
+          tests = parse_subcommand(args.first)
+          implementors = tests.map(&:implementor).uniq
+          # Logging.mdc['command'] = action
+          if [:clone, :bootstrap].include? action # actions on implementors
+            run_action(action, implementors)
+          else # actions on tests
+            run_action(action, tests)
+          end
+        end
+        banner "Polytrix is finished. #{Util.duration(elapsed.real)}"
+      end
+    end
+  end
+end

data/lib/polytrix/command/list.rb

@@ -0,0 +1,53 @@
+module Polytrix
+  module Command
+    class List < Polytrix::Command::Base
+      def call
+        # Logging.mdc['command'] = 'list'
+
+        setup
+        tests = parse_subcommand(args.first)
+
+        table = [
+          [
+            colorize('Suite', :green), colorize('Scenario', :green),
+            colorize('Implementor', :green), colorize('Status', :green)
+          ]
+        ]
+        table += tests.map do | challenge |
+          [
+            color_pad(challenge.suite),
+            color_pad(challenge.name),
+            color_pad(challenge.implementor.name),
+            format_last_action(challenge)
+          ]
+        end
+        shell.print_table table
+      end
+
+      private
+
+      def print_table(*args)
+        shell.print_table(*args)
+      end
+
+      def colorize(string, *args)
+        shell.set_color(string, *args)
+      end
+
+      def color_pad(string)
+        string + colorize('', :white)
+      end
+
+      def format_last_action(challenge)
+        case challenge.last_action
+        when 'clone' then colorize('Cloned', :cyan)
+        when 'bootstrap' then colorize('Bootstrapped', :magenta)
+        when 'exec' then colorize('Executed', :blue)
+        when 'verify' then colorize("Verified (Level #{challenge.verification_level})", :yellow)
+        when nil then colorize('<Not Found>', :red)
+        else colorize("<Unknown (#{challenge.last_action})>", :white)
+        end
+      end
+    end
+  end
+end

data/lib/polytrix/command/rundoc.rb

@@ -0,0 +1,27 @@
+module Polytrix
+  module Command
+    class RunDoc < Thor::Group
+      class_option :format,
+                   aliases: '-f',
+                   enum: %w(markdown rst),
+                   default: 'markdown',
+                   desc: 'The documentation input format'
+
+      def rundoc
+        files = args
+        # Logging.mdc['command'] = 'rundoc'
+        if files.empty?
+          # help('code2doc')
+          abort 'No FILES were specified, check usage above'
+        end
+
+        files.each do |file|
+          target_file_name = File.basename(file, File.extname(file)) + ".#{options[:format]}"
+          target_file = File.join(options[:target_dir], target_file_name)
+          say_status 'polytrix:code2doc', "Converting #{file} to #{target_file}"
+          Polytrix::DocumentationExecutor.new.execute file
+        end
+      end
+    end
+  end
+end

data/lib/polytrix/command/test.rb

@@ -0,0 +1,24 @@
+require 'polytrix/command'
+
+require 'benchmark'
+
+module Polytrix
+  module Command
+    # Command to test one or more instances.
+    class Test < Polytrix::Command::Base
+      include RunAction
+
+      # Invoke the command.
+      def call
+        banner "Starting Polytrix (v#{Polytrix::VERSION})"
+        elapsed = Benchmark.measure do
+          setup
+          results = parse_subcommand(args.join('|'))
+
+          run_action(:test, results)
+        end
+        banner "Polytrix is finished. #{Util.duration(elapsed.real)}"
+      end
+    end
+  end
+end