tconsole-rails4 2.2.0

data/lib/tconsole/server.rb

@@ -0,0 +1,174 @@
+module TConsole
+  class Server
+    attr_accessor :config, :reporter, :last_result
+
+    def initialize(config, reporter)
+      self.config = config
+      self.reporter = reporter
+      self.last_result = TConsole::TestResult.new
+    end
+    
+    # Internal: Outputs a message that a feature hasn't been implemented
+    def not_implemented
+      reporter.error("This feature hasn't been implemented yet.")
+    end
+
+    # Processes the message sent from the console
+    def handle(message)
+      action = message[:action]
+      args = message[:args]
+
+      send(action, *args)
+    end
+
+    def stop
+      Kernel.exit(0)
+    end
+
+    def load_environment
+      result = false
+
+      time = Benchmark.realtime do
+        reporter.info
+        reporter.info("Loading environment...")
+
+        begin
+          # Append our include paths
+          config.include_paths.each do |include_path|
+            $:.unshift(include_path)
+          end
+
+          config.before_load!
+
+          # Load our preload files
+          config.preload_paths.each do |preload_path|
+            require preload_path
+          end
+
+          config.after_load!
+
+          result = true
+        rescue Exception => e
+          reporter.error("Error - Loading your environment failed: #{e.message}")
+          reporter.trace_backtrace(e)
+          return false
+        end
+
+        preload_test_ids
+      end
+
+      reporter.info("Environment loaded in #{"%0.6f" % time}s.")
+      reporter.info
+
+      result
+    end
+
+    # Returns an array of possible completions based on the available element data
+    def autocomplete(text)
+      config.cached_elements.keys.grep(/^#{Regexp.escape(text)}/)
+    end
+
+    # Runs the given code in a block and returns the result of the code in the block.
+    # The block's result needs to be marshallable. Otherwise, nil is returned.
+    def run_in_fork(&block)
+     # Pipe for communicating with child so we can get its results back
+      read, write = IO.pipe
+
+      pid = fork do
+        read.close
+
+        result = block.call
+
+        write.puts([Marshal.dump(result)].pack("m0"))
+      end
+
+      write.close
+      response = read.read
+      read.close
+      Process.wait(pid)
+
+      begin
+        reporter.trace("Reading result from fork.")
+        Marshal.load(response.unpack("m")[0])
+      rescue => e
+        reporter.trace("Problem reading result from fork. Returning nil.")
+        reporter.trace(e.message)
+        nil
+      end
+    end
+
+    # Preloads our autocomplete cache
+    def preload_test_ids
+      # Does nothing by default
+    end
+
+    # Runs all tests against the match patterns given
+    def run_all_tests(match_patterns = nil)
+      reporter.error("This feature hasn't been implemented yet.")
+    end
+
+    # Runs a file set out of the config
+    def run_file_set(set)
+      reporter.error("This feature hasn't been implemented yet.")
+    end
+
+    def run_failed
+      reporter.error("This feature hasn't been implemented yet.")
+    end
+
+    def run_info
+      reporter.info("Defined Constants:")
+      reporter.info(Module.constants.sort.join("\n"))
+      reporter.info
+      reporter.info("Configuration:")
+      reporter.info("Mode: #{config.mode}")
+      reporter.info()
+      reporter.info
+    end
+
+    def show_performance(limit = nil)
+
+      limit = limit.to_i
+      limit = last_result.timings.length if limit == 0
+
+      sorted_timings = last_result.timings.sort_by { |timing| timing[:time] }
+
+      reporter.info
+      reporter.info("Timings from last run:")
+      reporter.info
+
+      if sorted_timings.length == 0
+        reporter.error("No timing data available. Be sure you've run some tests.")
+      else
+        sorted_timings.reverse[0, limit].each do |timing|
+          reporter.timing(timing, last_result.elements[timing[:name]])
+        end
+      end
+
+      reporter.info
+    end
+
+    def set(key, value)
+      if key == "fast"
+        if !value.nil?
+          value.downcase!
+          if ["on", "true", "yes"].include?(value)
+            config.fail_fast = true
+          else
+            config.fail_fast = false
+          end
+
+          reporter.exclaim("Fail Fast is now #{config.fail_fast ? "on" : "off"}")
+          reporter.exclaim
+        else
+          reporter.exclaim("Fail fast is currently #{config.fail_fast ? "on" : "off"}")
+          reporter.exclaim
+        end
+      else
+        reporter.warn("I don't know how to set `#{key}`.")
+        reporter.info("Usage: set {key} {value}")
+        reporter.warn
+      end
+    end
+  end
+end

data/lib/tconsole/test_result.rb

@@ -0,0 +1,65 @@
+module TConsole
+  class TestResult
+    # The number of failed tests in the last run
+    attr_accessor :failure_count
+
+    # The number of errors that occurred in the last run
+    attr_accessor :error_count
+
+    # The number of skipped tests
+    attr_accessor :skip_count
+
+    # Details about the failures in the last run
+    attr_accessor :failures
+
+    # The suites that we've run
+    attr_accessor :suites
+
+    # The timings for the tests we've run
+    attr_accessor :timings
+
+    # The element id lookup hash
+    attr_accessor :elements
+
+    # Test counts within various suites
+    attr_accessor :suite_counts
+
+    def initialize
+      self.failure_count = 0
+      self.error_count = 0
+      self.skip_count = 0
+      self.failures = []
+      self.suites = {}
+      self.timings = []
+
+      self.suite_counts = {}
+      self.elements = {}
+    end
+
+    def add_element(suite, method)
+      canonical_name = "#{suite}##{method}"
+
+      # Just return the id if we already know about this
+      if id = elements[canonical_name]
+        return id
+      end
+
+      # See if we know about this suite already
+      unless suite_id = elements[suite.to_s]
+        suite_id = self.suite_counts.length + 1
+        elements[suite.to_s] = suite_id
+        suite_counts[suite.to_s] ||= 0
+      end
+
+      suite_counts[suite.to_s] += 1
+      id = "#{suite_id}-#{suite_counts[suite.to_s]}"
+      elements[canonical_name] = id
+
+      id
+    end
+
+    def add_timing(suite, method, time)
+      self.timings << { :name => "#{suite}##{method}", :time => time }
+    end
+  end
+end

data/lib/tconsole/util.rb

@@ -0,0 +1,33 @@
+module TConsole
+  class Util
+    # Returns [width, height] of terminal when detected, nil if not detected.
+    # Think of this as a simpler version of Highline's Highline::SystemExtensions.terminal_size()
+    #
+    # This is a copy of HIRB's terminal size detection code: https://github.com/cldwalker/hirb/blob/master/lib/hirb/util.rb
+    def self.detect_terminal_size
+      if (ENV['COLUMNS'] =~ /^\d+$/) && (ENV['LINES'] =~ /^\d+$/)
+        [ENV['COLUMNS'].to_i, ENV['LINES'].to_i]
+      elsif (RUBY_PLATFORM =~ /java/ || (!STDIN.tty? && ENV['TERM'])) && command_exists?('tput')
+        [`tput cols`.to_i, `tput lines`.to_i]
+      elsif STDIN.tty? && command_exists?('stty')
+        `stty size`.scan(/\d+/).map { |s| s.to_i }.reverse
+      else
+        nil
+      end
+    rescue
+      nil
+    end
+
+    # Public: Filters a backtrace to exclude things that happened in TConsole
+    #
+    # backtrace: The backtrace array that we're filtering.
+    #
+    # Returns the updated backtrace.
+    def self.filter_backtrace(backtrace)
+      tconsole_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..")) + File::SEPARATOR
+      backtrace.select do |item|
+        !item.start_with?(tconsole_path)
+      end
+    end
+  end
+end

data/lib/tconsole/version.rb

@@ -0,0 +1,3 @@
+module TConsole
+  VERSION = "2.2.0"
+end

data/spec/config_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe TConsole::Config do
+  context "a Config without arguments" do
+    before do
+      @config = TConsole::Config.new(:minitest, [])
+      @config.test_dir = "./spec/fixtures/minitest"
+    end
+
+    context "when configured test directory doesn't exist" do
+      before do
+        @config.test_dir = "./monkey_business"
+      end
+
+      it "sets a validation error" do
+        expect(@config.validation_errors[0]).to eq("Couldn't find test directory `./monkey_business`. Exiting.")
+      end
+    end
+
+    context "when the configuration doesn't include an all file set" do
+      before do
+        @config.file_sets = {}
+      end
+
+      it "sets a validation error" do
+        expect(@config.validation_errors[0]).to eq("No `all` file set is defined in your configuration. Exiting.")
+      end
+    end
+  end
+
+  context "a Config with the trace argument" do
+    before do
+      @config = TConsole::Config.new(:minitest, Shellwords.shellwords("--trace"))
+    end
+
+    it "has tracing enabled" do
+      expect(@config.trace_execution).to be_true
+    end
+  end
+
+  context "a Config with the once argument" do
+    before do
+      @config = TConsole::Config.new(:minitest, Shellwords.shellwords("--once all"))
+    end
+
+    it "has run once enabled" do
+      expect(@config.once).to be_true
+    end
+  end
+
+  context "a Config with remaining arguments" do
+    before do
+      @config = TConsole::Config.new(:minitest, Shellwords.shellwords("--trace set fast on"))
+    end
+
+    it "sets remaining args as first command" do
+      expect(@config.run_command).to eq("set fast on")
+    end
+  end
+
+  describe ".run" do
+    before do
+      TConsole::Config.run do |config|
+        config.test_dir = "./awesome_sauce"
+      end
+    end
+
+    after do
+      TConsole::Config.clear_loaded_configs
+    end
+
+    it "saves the run proc" do
+      loaded_configs = TConsole::Config.instance_variable_get(:@loaded_configs)
+      expect(loaded_configs.length).to eq(1)
+    end
+
+    it "runs loaded configs from first to last" do
+      TConsole::Config.run do |config|
+        config.test_dir = "./awesomer_sauce"
+      end
+
+      config = TConsole::Config.configure(:minitest)
+      expect(config.test_dir).to eq("./awesomer_sauce")
+    end
+  end
+
+  describe ".load_config" do
+    it "loads configs" do
+      TConsole::Config.load_config(File.join(File.dirname(__FILE__), "sample_config"))
+      loaded_configs = TConsole::Config.instance_variable_get(:@loaded_configs)
+      expect(loaded_configs.length).to eq(1)
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe TConsole::Runner do
+  before do
+    @runner = TConsole::Runner.new(:minitest)
+    @ps = ChattyProc::PipeServer.new
+  end
+
+  describe "#load_environment" do
+    before do
+      @ps.stub(:write) { }
+    end
+
+    it "returns false if the environment load call fails" do
+      @ps.stub(:read) { false }
+      expect(@runner.load_environment(@ps)).to be_false
+    end
+
+    it "returns true if the environment load call succeeds" do
+      @ps.stub(:read) { true }
+      expect(@runner.load_environment(@ps)).to be_true
+    end
+  end
+
+  describe "#console_run_loop" do
+    before do
+      @config = TConsole::Config.new(:minitest)
+      @reporter = TConsole::Reporter.new(@config)
+      @console = TConsole::Console.new(@config, @reporter)
+    end
+
+    it "returns false when loading the environment fails" do
+      @runner.stub(:load_environment) { false }
+
+      expect(@runner.console_run_loop(@console)).to be_false
+    end
+  end
+end

data/spec/sample_config

@@ -0,0 +1,3 @@
+TConsole::Config.run do |config|
+  config.test_dir = "./awesome_sauce"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require "rubygems"
+require "bundler/setup"
+
+require 'tconsole'

data/spec/util_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe "TConsole::Util" do
+  describe ".filter_backtrace" do
+    before do
+      @non_tconsole_path = "/Users/alan/Projects/commondream/tconsole-test/test/functional/posts_controller_test.rb:16:in `block in <class:PostsControllerTest>'"
+      @tconsole_path = "#{File.expand_path(File.join(File.dirname(__FILE__), ".."))}/posts_controller_test.rb:16:in `block in <class:PostsControllerTest>'"
+
+      @backtrace = [
+        @non_tconsole_path,
+        @tconsole_path
+      ]
+
+      @filtered_backtrace = TConsole::Util.filter_backtrace(@backtrace)
+    end
+
+    context "removes tconsole paths" do
+      it { expect(@filtered_backtrace.length).to eq(1) }
+      it { expect(@filtered_backtrace).to_not include(@tconsole_path) }
+    end
+
+    it "doesn't remove non-tconsole paths" do
+      expect(@filtered_backtrace).to include(@non_tconsole_path)
+    end
+  end
+end