duck_test 0.1.4

data/bin/ducktest

@@ -0,0 +1,29 @@
+#!/usr/local/bin/ruby
+
+require 'rubygems'
+
+version = ">= 0"
+
+if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+# get a list of all arguments passed on the CLI that DO NOT begin with a hyphen
+values = ARGV.find_all {|item| !item.match(/^-/)}
+
+# remove any arguments that DO NOT exist in the args array
+args = %w(c development production test)
+values.delete_if {|arg| args.include?(arg)}
+
+# the remaining arguments should be arguments that are NOT SUPPORTED via the console, however,
+# are useful for ducktest.  Save them for later use.
+if ENV["DUCK_TEST"].nil? || ENV["DUCK_TEST"].empty?
+  ENV["DUCK_TEST"] = values.first
+end
+
+# now, remove them from the CLI args so the console doesn't puke...
+ARGV.delete_if {|arg| values.include?(arg)}
+
+gem 'rails', version
+load Gem.bin_path('rails', 'rails', version)

data/lib/duck_test/autoload_config.rb

@@ -0,0 +1,103 @@
+module DuckTest
+
+  ##################################################################################
+  # Helper methods for configuring autoload paths during startup.  One of the requirements essential to running tests in the console
+  # is making all of the module and class files visible to the console environment.  Typically, this is accomplished via config/application.rb
+  # by adding to the autoload_paths like the following:
+  #
+  #    config.autoload_paths += %W(#{Rails.root}/test)
+  #
+  # During startup DuckTest will attempt to take this step for you prior to configuration using a before_configuration block inside
+  # the Railtie class for the gem.  You can guide this behavior in a couple of ways using a config file in two locations.
+  #
+  # - In the home directory of your file system: ~/.ducktestrc
+  # - In the root directory of your Rails application: Rails.root/.ducktest
+  #
+  # Notice the slight difference in the file names.  One with rc and one without.  The default configuration is to load each directory for
+  # each supported testing framework if the directory exists.  Currently, testunit and rspec are the two testing frameworks.
+  # The startup process goes something like this:
+  #
+  # 1. load configuration settings from disk
+  # 2. determine the current Rails environment: test, development, production.
+  # 3. loop thru each directory from the config.  if the directory is configured to be added to the autoload_path and
+  #    the directory actually exists, then, it is added, otherwise, it is ignored.
+  #
+  # The following is a sample config file.
+  #    ---
+  #    test:          # represents the Rails environment
+  #      test: true   # represents an app directory directly off of the app root
+  #      spec: true
+  #
+  #    development:
+  #      test: true
+  #      spec: false
+  #
+  # The default configuration is to add test and spec directories to the autoload_path.  You can easily prevent any of them by setting
+  # the boolean value to false.  You can add additional directories by adding the directory name and true.
+  #
+  # Load order:
+  # The default config for test and development is to add the test and spec directories if they exist.  The config file ~/.ducktestrc
+  # in the home directory is loaded and merged with the default config and will override it's values.  Next, the config file .ducktest in the app
+  # directory is loaded and merged with the default config and will override it's values.  So, the rule is simple.
+  # - home directory overrides default
+  # - app directory overrides both
+  class AutoloadConfig
+    include LoggerHelper
+  
+    attr_accessor :paths
+
+    ##################################################################################
+    # Do I really have to say it?
+    def initialize
+      super
+      self.paths = []
+      self.load_config
+    end
+
+    ##################################################################################
+    # Loads config settings for autoload paths
+    def load_config
+      config = {test: {test: true, spec: true}, development: {test: false, spec: false}}
+
+      if File.exists?("~/.ducktestrc")
+        config = merge(config, YAML.load_file("~/.ducktestrc"))
+      end
+
+      if File.exists?("#{Rails.root}/.ducktest")
+        config = merge(config, YAML.load_file("#{Rails.root}/.ducktest"))
+      end
+
+      config.each do |item|
+        if Rails.env.eql?(item.first.to_s)
+          item.last.each do |path|
+            if path.last
+              file_spec = "#{Rails.root}/#{path.first}"
+              if File.exist?(file_spec)
+                self.paths.push(file_spec)
+                ducklog.system "Adding path to autoload_paths: #{file_spec}"
+              end
+            end
+          end
+          break
+        end
+      end
+
+    end
+
+    ##################################################################################
+    # Loads config settings for autoload paths
+    def merge(config, buffer)
+      buffer = buffer.symbolize_keys
+      config.each do |item|
+        if item.last.kind_of?(Hash)
+          if buffer[item.first]
+            item.last.merge!(buffer[item.first].symbolize_keys)
+          end
+        end
+      end
+      return config
+    end
+
+  end
+
+end

data/lib/duck_test/base.rb

@@ -0,0 +1,41 @@
+# DuckTest Base module
+require "duck_test/version"
+
+module DuckTest
+
+  autoload :AutoloadConfig, 'duck_test/autoload_config'
+  autoload :Config, 'duck_test/config'
+  autoload :ConfigHelper, 'duck_test/config_helper'
+  autoload :Console, 'duck_test/console'
+  autoload :Commands, 'duck_test/commands'
+  autoload :DefaultConfig, 'duck_test/default_config'
+  autoload :FrameWork, 'duck_test/frame_work/base'
+  autoload :Logger, 'duck_test/logger'
+  autoload :LoggerHelper, 'duck_test/logger'
+  autoload :Platforms, 'duck_test/platforms/base'
+  autoload :Usage, 'duck_test/usage'
+  autoload :VersionHelper, 'duck_test/version'
+
+  ##################################################################################
+  # Executes a configuration block to define watch lists, etc.
+  #
+  #   DuckTest.config do
+  #
+  #     runnable "**/*"
+  #
+  #   end
+  #
+  # @return [DuckTest::Config] Returns DuckTest::Config instance if a block is passed.
+  def self.config(&block)
+    config = nil
+
+    if block_given?
+      config = DuckTest::Config.new
+      config.instance_exec(&block)
+      config.class.block_run = true
+    end
+
+    return config
+  end
+
+end

data/lib/duck_test/commands.rb

@@ -0,0 +1,208 @@
+module DuckTest
+
+  # Console commands
+  class Commands
+
+    include LoggerHelper
+    include Usage
+
+    ##################################################################################
+    def initialize
+      super
+    end
+
+    ##################################################################################
+    # Displays standard usage details
+    def to_s
+      usage(:usage, true)
+      return nil
+    end
+
+    ##################################################################################
+    # See {Logger.log_level}
+    # @return [String] The output message
+    def ar(value = nil)
+      if value.blank?
+        usage(:ar, true)
+        msg = "Current log level: #{Logger.to_severity(ActiveRecord::Base.logger.level)}"
+      else
+        # converts from a symbol to a number
+        ActiveRecord::Base.logger.level = Logger.to_severity(value)
+        msg = "Log level set to: #{value}"
+      end
+      return msg
+    end
+
+    ##################################################################################
+    # Toggles autorun on/off.
+    # @return [String] The output message
+    def autorun
+      return DuckTest::Config.framework.toggle_autorun
+    end
+
+    ##################################################################################
+    # Lists all of the files that have been blacklisted.
+    # @return [String] The output message
+    def blacklist
+      list = []
+      DuckTest::Config.framework.black_list.each {|item| list.push(item.first)}
+      list.sort.each {|item| ducklog.console item}
+      return ""
+    end
+
+    ##################################################################################
+    # Lists all of the non-runnable and runnable files that have been loaded into memory during the current session.
+    # @return [String] The output message
+    def history
+      framework = DuckTest::Config.framework
+
+      ducklog.console "================================="
+
+      if framework.non_loadable_history.length > 0 || framework.non_runnable_history.length > 0 || framework.runnable_history.length > 0
+
+        ducklog.console "\r\n  Non-loadable file(s)" if framework.non_loadable_history.length > 0
+
+        framework.non_loadable_history.each do |file_spec|
+          ducklog.console "      #{file_spec.gsub("#{framework.root}#{File::SEPARATOR}", "")}"
+        end
+
+        ducklog.console "\r\n  Non-runnable file(s)" if framework.non_runnable_history.length > 0
+
+        framework.non_runnable_history.each do |file_spec|
+          ducklog.console "      #{file_spec.gsub("#{framework.root}#{File::SEPARATOR}", "")}"
+        end
+
+        ducklog.console "\r\n  Runnable file(s)" if framework.runnable_history.length > 0
+
+        framework.runnable_history.each do |file_spec|
+          ducklog.console "      #{file_spec.gsub("#{framework.root}#{File::SEPARATOR}", "")}"
+        end
+
+      else
+        ducklog.console "  Zero files have been changed and run"
+      end
+
+      return ""
+    end
+
+    ##################################################################################
+    # Displays information about the current loaded testing framework.
+    # @return [String] The output message
+    def info
+      puts DuckTest::Config.framework.info
+      return ""
+    end
+
+    ##################################################################################
+    # See {FrameWork::Queue#latency}
+    # @return [String] The output message
+    def latency(value = nil)
+      unless usage(:latency, value.blank?)
+        DuckTest::Config.framework.set_latency(value.to_f)
+        msg = "Queue latency set to: #{value}"
+      end
+      return msg
+    end
+
+    ##################################################################################
+    # See {Platforms::Listener#speed}
+    # @return [String] The output message
+    def listen_speed(value = nil)
+      msg = nil
+      unless usage(:listen_speed, value.blank?)
+        DuckTest::Config.framework.set_listener_speed(value.to_f)
+        msg = "Listener speed set to: #{value}"
+      end
+      return msg
+    end
+
+    ##################################################################################
+    # See {Logger.log_level}
+    # @return [String] The output message
+    def ll(value = nil)
+      if value.blank?
+        usage(:ll, true)
+        msg = "Current log level: #{Logger.to_severity(Logger.log_level)}"
+      else
+        Logger.log_level = value
+        msg = "Log level set to: #{value}"
+      end
+      return msg
+    end
+
+    ##################################################################################
+    # Lists mappings of non-runnable to runnable files.
+    # @return [String] The output message
+    def maps
+      framework = DuckTest::Config.framework
+
+      framework.watch_configs.each do |watch_config|
+        ducklog.console "================================="
+        ducklog.console "     pattern: #{watch_config.pattern}"
+        ducklog.console "  runnrable?: #{watch_config.runnable?}"
+        ducklog.console "       maps?: #{watch_config.maps.length > 0 ? true : false}"
+        ducklog.console ""
+
+        if watch_config.maps.length > 0
+          framework.white_list.each do |file_object|
+            if file_object.last[:watch_config].eql?(watch_config)
+              unless file_object.last[:is_dir]
+                runnable_files = framework.find_runnable_files(file_object.first, file_object.last[:watch_config])
+                if runnable_files.length > 0
+                  ducklog.console "        #{file_object.first.gsub("#{framework.root}#{File::SEPARATOR}", "")}"
+                  runnable_files.each do |file_spec|
+                    ducklog.console "            executes ==> #{file_spec.gsub("#{framework.root}#{File::SEPARATOR}", "")}"
+                  end
+                end
+              end
+            end
+          end
+        end
+
+      end
+
+      return ""
+    end
+
+    ##################################################################################
+    # Runs all tests that have been automagically loaded via the queue as a result of a file change or
+    # loaded manually with the load command.
+    # @return [String] The output message
+    def run(value=nil)
+      unless usage(:run, value.kind_of?(Symbol) && value.eql?(:help))
+        return DuckTest::Config.framework.run_manually(value)
+      end
+    end
+
+    ##################################################################################
+    # Loads all runnable test files from disk and executes the run_tests method.
+    # @return [String] The output message
+    def runall
+      return DuckTest::Config.framework.run_all
+    end
+
+    ##################################################################################
+    # See {FrameWork::Queue#speed}
+    # @return [String] The output message
+    def speed(value = nil)
+      msg = nil
+      unless usage(:speed, value.blank?)
+        DuckTest::Config.framework.set_queue_speed(value.to_f)
+        msg = "Queue speed set to: #{value}"
+      end
+      return msg
+    end
+
+    ##################################################################################
+    # Lists all of the files that have been whitelisted.
+    # @return [String] The output message
+    def whitelist
+      list = []
+      DuckTest::Config.framework.white_list.each {|item| list.push(item.first)}
+      list.sort.each {|item| ducklog.console item}
+      return ""
+    end
+
+  end
+end
+