omnitest 0.2.1

data/lib/omnitest/command/task.rb

@@ -0,0 +1,27 @@
+require 'benchmark'
+
+module Omnitest
+  module Command
+    class Task < Omnitest::Command::Base
+      include RunAction
+
+      # Invoke the command.
+      def call
+        banner "Starting Omnitest (v#{Omnitest::VERSION})"
+        elapsed = Benchmark.measure do
+          setup
+          task = args.shift
+          project_regex = args.shift
+          projects = Omnitest.filter_projects(project_regex)
+          if options[:exec]
+            run_action(projects, :execute, options[:concurrency])
+          else
+            run_action(projects, task, options[:concurrency])
+          end
+        end
+        #  Need task summary...
+        banner "Omnitest is finished. #{Core::Util.duration(elapsed.real)}"
+      end
+    end
+  end
+end

data/lib/omnitest/command/test.rb

@@ -0,0 +1,41 @@
+require 'omnitest/command'
+
+require 'benchmark'
+
+module Omnitest
+  module Command
+    # Command to test one or more instances.
+    class Test < Omnitest::Command::Base
+      include RunAction
+
+      # Invoke the command.
+      def call
+        banner "Starting Omnitest (v#{Omnitest::VERSION})"
+        scenarios = nil
+        elapsed = Benchmark.measure do
+          setup
+          scenarios = parse_subcommand(args.shift, args.shift)
+
+          run_action(scenarios, :test, options[:concurrency])
+        end
+        banner "Omnitest is finished. #{Core::Util.duration(elapsed.real)}"
+        test_summary(scenarios)
+      end
+
+      def test_summary(scenarios)
+        # TODO: Need an actual test summary
+        failed_scenarios = scenarios.select do | s |
+          !s.status_description.match(/Fully Verified|<Not Found>/)
+        end
+
+        shell.say
+        failed_scenarios.each do | scenario |
+          shell.say_status scenario.status_description, scenario.slug
+        end
+        status_line = "#{scenarios.size} scenarios, #{failed_scenarios.size} failures" # , x pending
+        shell.say status_line
+        abort unless failed_scenarios.empty?
+      end
+    end
+  end
+end

data/lib/omnitest/configuration.rb

@@ -0,0 +1,53 @@
+
+require 'rspec/support'
+require 'rspec/expectations'
+
+module Omnitest
+  RESOURCES_DIR = File.expand_path '../../../resources', __FILE__
+
+  class Configuration < Omnitest::Core::Dash
+    extend Forwardable
+    field :dry_run, Object, default: false
+    field :log_root, Pathname, default: '.omnitest/logs'
+    field :log_level, Symbol, default: :info
+    field :travis, Object, default: false
+    field :concurrency, Integer
+
+    # TODO: This should probably be configurable, or tied to Thor color options.
+    if RSpec.respond_to?(:configuration)
+      RSpec.configuration.color = true
+    else
+      RSpec::Expectations.configuration.color = true
+    end
+
+    def skeptic
+      Skeptic.configuration
+    end
+
+    def default_logger
+      @default_logger ||= ProjectLogger.new(stdout: $stdout, level: Core::Util.to_logger_level(log_level))
+    end
+
+    def project_set
+      @project_set ||= load_project_set('omnitest.yaml')
+    end
+
+    def project_set=(project_set_data)
+      if project_set_data.is_a? Skeptic::TestManifest
+        @project_set = project_set_data
+      else
+        @project_set = ProjectSet.from_yaml project_set_data
+      end
+      @project_set
+    rescue Errno::ENOENT => e
+      raise UserError, "Could not load test manifest: #{e.message}"
+    end
+
+    def clear
+      skeptic.clear
+      super
+    end
+
+    alias_method :load_project_set, :project_set=
+  end
+end

data/lib/omnitest/documentation_generator.rb

@@ -0,0 +1,68 @@
+require 'tilt' # padrino-helpers wants you to pre-require tilt/erubis
+require 'erubis'
+require 'padrino-helpers'
+
+module Omnitest
+  class DocumentationGenerator
+    [
+      Padrino::Helpers::OutputHelpers,
+      Padrino::Helpers::AssetTagHelpers,
+      Padrino::Helpers::TagHelpers,
+      Omnitest::Psychic::Code2Doc::CodeHelper
+    ].each do | helper|
+      include helper
+    end
+
+    attr_reader :scenario
+
+    def initialize(template_file = nil, scenario = nil)
+      @scenario = scenario
+      @template_file = template_file
+    end
+
+    def process(scenarios)
+      return nil unless File.readable? @template_file
+
+      @scenarios = scenarios
+      erb = ERB.new File.read(@template_file)
+      @result = erb.result(binding) || ''
+    end
+
+    def save(target_file)
+      fail 'No results to write, please call process before save' if @result.nil? || @result.empty?
+
+      FileUtils.mkdir_p File.dirname(target_file)
+      File.open(target_file, 'wb') do |f|
+        f.write @result
+      end
+    end
+
+    def code2doc(source_file, language = nil)
+      source_code = File.read(source_file)
+      segmenter_language ||= infer_language(source_file)
+
+      buffer = StringIO.new
+      segmenter_options = {
+        language: language
+      }
+      segmenter = Omnitest::Psychic::Code2Doc::CodeSegmenter.new(segmenter_options)
+      segments = segmenter.segment source_code
+      segments.each do |comment, code|
+        comment = comment.join("\n")
+        code = code.join("\n")
+        code = code_block(code, language) unless code.empty?
+        next if comment.empty? && code.empty?
+        code = "\n#{code}\n" if !comment.empty? && !code.empty? # Markdown needs separation
+        buffer.puts [comment, code].join("\n")
+      end
+      buffer.string
+    end
+
+    private
+
+    def infer_language(source_file)
+      language, comment_style = Psychic::Code2Doc::CommentStyles.infer File.extname(source_file)
+      segmenter_language = comment_style[:language] || language
+    end
+  end
+end

data/lib/omnitest/project.rb

@@ -0,0 +1,100 @@
+module Omnitest
+  class Project < Omnitest::Core::Dash
+    include Omnitest::Core::Logging
+    include Omnitest::Core::FileSystem
+
+    class GitOptions < Omnitest::Core::Dash
+      required_field :repo, String
+      field :branch, String
+      field :to, String
+
+      def initialize(data)
+        data = { repo: data } if data.is_a? String
+        super
+      end
+    end
+
+    field :name, String
+    field :basedir, Pathname
+    field :language, String
+    field :git, GitOptions
+
+    alias_method :cwd, :basedir
+
+    attr_accessor :psychic, :skeptic
+
+    def psychic
+      @psychic ||= Omnitest::Psychic.new(name: name, cwd: basedir, logger: logger, travis: Omnitest.configuration.travis)
+    end
+
+    def skeptic
+      @skeptic ||= Omnitest::Skeptic.new(psychic)
+    end
+
+    def execute(*args)
+      psychic.execute(*args)
+    end
+
+    def basedir
+      self[:basedir] ||= "projects/#{name}"
+    end
+
+    def logger
+      @logger ||= Omnitest.new_logger(self)
+    end
+
+    def clone
+      if git.nil? || git.repo.nil?
+        logger.info 'Skipping clone because there are no git options'
+        return
+      end
+      branch = git.branch ||= 'master'
+      target_dir = git.to ||= basedir
+      target_dir = Omnitest::Core::FileSystem.relativize(target_dir, Omnitest.basedir)
+      if File.exist? target_dir
+        logger.info "Skipping clone because #{target_dir} already exists"
+      else
+        clone_cmd = "git clone #{git.repo} -b #{branch} #{target_dir}"
+        logger.info "Cloning: #{clone_cmd}"
+        Omnitest.psychic.execute(clone_cmd)
+      end
+    end
+
+    def task(task_name, opts = { fail_if_missing: true })
+      banner_msg = opts[:custom_banner] || "Running task #{task_name} for #{name}"
+      banner banner_msg
+      fail "Project #{name} has not been cloned" unless cloned?
+      psychic.task(task_name).execute
+    rescue Omnitest::Psychic::TaskNotImplementedError => e
+      if opts[:fail_if_missing]
+        logger.error("Could not run task #{task_name} for #{name}: #{e.message}")
+        raise ActionFailed.new("Failed to run task #{task_name} for #{name}: #{e.message}", e)
+      else
+        logger.warn "Skipping #{task_name} for #{name}, no #{task_name} task exists"
+      end
+    end
+
+    def workflow(workflow_name)
+      workflow_definition = Omnitest.configuration.project_set.workflows[workflow_name]
+      fail UserError, "Workflow '#{workflow_name}' is not defined" if workflow_definition.nil?
+
+      workflow = psychic.workflow(workflow_name) do
+        workflow_definition.tasks.each do | task_name |
+          task task_name
+        end
+      end
+
+      workflow.execute
+    rescue Psychic::TaskNotImplementedError => e
+      raise UserError, "Cannot run workflow '#{workflow_name}' for project '#{name}': #{e.message}"
+    end
+
+    def bootstrap
+      task('bootstrap', custom_banner: "Bootstrapping #{name}", fail_if_missing: false)
+    end
+
+    def cloned?
+      File.directory? basedir
+    end
+  end
+end

data/lib/omnitest/project_logger.rb

@@ -0,0 +1,273 @@
+require 'fileutils'
+require 'logger'
+
+module Omnitest
+  class ProjectLogger
+    include ::Logger::Severity
+
+    # @return [IO] the log device
+    attr_reader :logdev
+
+    # Constructs a new logger.
+    #
+    # @param options [Hash] configuration for a new logger
+    # @option options [Symbol] :color color to use when when outputting
+    #   messages
+    # @option options [Integer] :level the logging severity threshold
+    #   (default: `Omnitest::DEFAULT_LOG_LEVEL`)
+    # @option options [String,IO] :logdev filepath String or IO object to be
+    #   used for logging (default: `nil`)
+    # @option options [String] :progname program name to include in log
+    #   messages (default: `"Omnitest"`)
+    # @option options [IO] :stdout a standard out IO object to use
+    #   (default: `$stdout`)
+    def initialize(options = {})
+      color = options[:color]
+
+      @loggers = []
+      @loggers << @logdev = logdev_logger(options[:logdev]) if options[:logdev]
+      @loggers << stdout_logger(options[:stdout], color) if options[:stdout]
+      @loggers << stdout_logger($stdout, color) if @loggers.empty?
+
+      self.progname = options[:progname] || 'Omnitest'
+      self.level = options[:level] || default_log_level
+    end
+
+    class << self
+      private
+
+      # @api private
+      # @!macro delegate_to_first_logger
+      #   @method $1()
+      def delegate_to_first_logger(meth)
+        define_method(meth) { |*args| @loggers.first.public_send(meth, *args) }
+      end
+
+      # @api private
+      # @!macro delegate_to_all_loggers
+      #   @method $1()
+      def delegate_to_all_loggers(meth)
+        define_method(meth) do |*args|
+          result = nil
+          @loggers.each { |l| result = l.public_send(meth, *args) }
+          result
+        end
+      end
+    end
+
+    # @return [Integer] the logging severity threshold
+    # @see http://is.gd/Okuy5p
+    delegate_to_first_logger :level
+
+    # Sets the logging severity threshold.
+    #
+    # @param level [Integer] the logging severity threshold
+    # @see http://is.gd/H1VBFH
+    delegate_to_all_loggers :level=
+
+    # @return [String] program name to include in log messages
+    # @see http://is.gd/5uHGK0
+    delegate_to_first_logger :progname
+
+    # Sets the program name to include in log messages.
+    #
+    # @param progname [String] the program name to include in log messages
+    # @see http://is.gd/f2U5Xj
+    delegate_to_all_loggers :progname=
+
+    # @return [String] the date format being used
+    # @see http://is.gd/btmFWJ
+    delegate_to_first_logger :datetime_format
+
+    # Sets the date format being used.
+    #
+    # @param format [String] the date format
+    # @see http://is.gd/M36ml8
+    delegate_to_all_loggers :datetime_format=
+
+    # Log a message if the given severity is high enough.
+    #
+    # @see http://is.gd/5opBW0
+    delegate_to_all_loggers :add
+
+    # Dump one or more messages to info.
+    #
+    # @param message [#to_s] the message to log
+    # @see http://is.gd/BCp5KV
+    delegate_to_all_loggers :<<
+
+    # Log a message with severity of banner (high level).
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/pYUCYU
+    delegate_to_all_loggers :banner
+
+    # Log a message with severity of debug.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/Re97Zp
+    delegate_to_all_loggers :debug
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of debug messages
+    # @see http://is.gd/Iq08xB
+    delegate_to_first_logger :debug?
+
+    # Log a message with severity of info.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/pYUCYU
+    delegate_to_all_loggers :info
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of info messages
+    # @see http://is.gd/lBtJkT
+    delegate_to_first_logger :info?
+
+    # Log a message with severity of error.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/mLwYMl
+    delegate_to_all_loggers :error
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of error messages
+    # @see http://is.gd/QY19JL
+    delegate_to_first_logger :error?
+
+    # Log a message with severity of warn.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/PX9AIS
+    delegate_to_all_loggers :warn
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of warn messages
+    # @see http://is.gd/Gdr4lD
+    delegate_to_first_logger :warn?
+
+    # Log a message with severity of fatal.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/5ElFPK
+    delegate_to_all_loggers :fatal
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of fatal messages
+    # @see http://is.gd/7PgwRl
+    delegate_to_first_logger :fatal?
+
+    # Log a message with severity of unknown.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/Y4hqpf
+    delegate_to_all_loggers :unknown
+
+    # Close the logging devices.
+    #
+    # @see http://is.gd/b13cVn
+    delegate_to_all_loggers :close
+
+    private
+
+    # @return [Integer] the default logger level
+    # @api private
+    def default_log_level
+      Omnitest::Core::Util.to_logger_level(Omnitest.configuration.log_level)
+    end
+
+    # Construct a new standard out logger.
+    #
+    # @param stdout [IO] the IO object that represents stdout (or similar)
+    # @param color [Symbol] color to use when outputing messages
+    # @return [StdoutLogger] a new logger
+    # @api private
+    def stdout_logger(stdout, color)
+      logger = Omnitest::Core::StdoutLogger.new(stdout)
+      if Omnitest.tty?
+        logger.formatter = proc do |_severity, _datetime, _progname, msg|
+          Core::Color.colorize("#{msg}", color).concat("\n")
+        end
+      else
+        logger.formatter = proc do |_severity, _datetime, _progname, msg|
+          msg.concat("\n")
+        end
+      end
+      logger
+    end
+
+    # Construct a new logdev logger.
+    #
+    # @param filepath_or_logdev [String,IO] a filepath String or IO object
+    # @return [LogdevLogger] a new logger
+    # @api private
+    def logdev_logger(filepath_or_logdev)
+      Omnitest::Core::LogdevLogger.new(resolve_logdev(filepath_or_logdev))
+    end
+
+    # Return an IO object from a filepath String or the IO object itself.
+    #
+    # @param filepath_or_logdev [String,IO] a filepath String or IO object
+    # @return [IO] an IO object
+    # @api private
+    def resolve_logdev(filepath_or_logdev)
+      if filepath_or_logdev.is_a? String
+        FileUtils.mkdir_p(File.dirname(filepath_or_logdev))
+        file = File.open(File.expand_path(filepath_or_logdev), 'ab')
+        file.sync = true
+        file
+      else
+        filepath_or_logdev
+      end
+    end
+  end
+end