tconsole-rails4 2.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 727e3e5b196fe93217c38ecac412d29386f85bd3
+  data.tar.gz: 86daceb46835fe5f7dcfa1b82d868834335cff76
+SHA512:
+  metadata.gz: 33ced7d8bdd58a228239a840e5d8e938a7eb54843baa53e3e8d53829eeec34ef32e48b50cbed41af9b50658a42d666a661cccfafbd3394df131961ca1472b90e
+  data.tar.gz: e8e317d473e6c1914a8897feacf6ede04462237cc217cb369f8bf2aa9e8addcd7850ad1e604518801a150059826b7fdfe13ad2d2296ef32bc9d86581bcbda45a

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc
+.rspec

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "bundle/nerdcommenter"]
+	path = bundle/nerdcommenter
+	url = git://github.com/scrooloose/nerdcommenter.git

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in tconsole.gemspec
+gemspec
+
+gem 'rake'
+gem 'rspec'
+gem 'minitest', '5.0.2'

data/README.md

@@ -0,0 +1,293 @@
+TConsole
+======
+
+TConsole is a testing console for Rails. It allows you to issue commands
+concerning what tests to run, and see their test output. It's also got a
+helpful reload command for when your Rails environment needs to be
+restarted.
+
+TConsole should work in pretty much any Unix environment and will work
+with apps running Ruby 1.9. It can be run on pretty much any test suite
+that uses MiniTest, including Rails test suites (though MiniTest::Spec
+isn't supported, unfortunately).
+
+It was written by [Alan Johnson][], who passed maintainership over to
+[Graham Ashton][] in July 2013.
+
+[Alan Johnson]: https://github.com/commondream
+[Graham Ashton]: https://github.com/gma
+
+See it in Action
+------
+
+There's a quick screencast on Vimeo about TConsole's basic features:
+[Meet TConsole!](https://vimeo.com/37641415)
+
+Why use TConsole?
+------
+
+* A large amount of time is wasted loading the Rails environment each
+  time you run the Rails testing rake tasks. TConsole loads the
+  environment when you start the console and whenever you reload the
+  environment, but doesn't have to reload the environment for each test
+  execution.
+* The Rails rake task syntax `bundle exec rake test:units
+  TEST=test/unit/user_test.rb` can be pretty verbose when you're running
+  specific tests. Yeah, there are tricks you can use to shorten things
+  up, but still, that's crazy long. tconsole lets you just type
+  `test/unit/user_test.rb` to get that specific test file to run. With
+  TConsole  you can just type `UserTest` and the test runs!
+* TConsole makes it dead simple to review how long your tests are taking
+  to run and pinpoint your slowest running tests.
+* Re-running failed tests is as easy as typing `!failed` with TConsole.
+
+What about Spork?
+------
+
+[Spork](https://github.com/sporkrb/spork)'s really cool, and it was my
+primary motivation behind writing tconsole, but I've always felt like
+having an extra console open for my spork server and another to run my
+commands is a bit heavy for what I want to do. Beyond that, I couldn't
+ever figure out how to get Spork to work with test/unit, and since me
+and DHH are the only two people who still use test/unit I figured it was
+up to me to come up with something that worked great. If Spork's your
+cup of tea, though, stop reading this and use what you like.
+
+What about rspec?
+------
+
+We've decided to focus on integrating with MiniTest as tightly as
+possible, rather than worrying about rspec support.
+
+Installing TConsole
+------
+    gem install tconsole
+
+Prereleases of TConsole come out pretty frequently. You can install the
+latest prerelease version with:
+
+    gem install tconsole --pre
+    
+If you're using bundler, you probably want to simply add TConsole to
+your Gemfile:
+
+    gem "tconsole"
+
+How to use TConsole
+------
+
+In your shell of choice, cd into your Rails project's directory and then
+run `bundle exec tconsole` to fire up the console. You should see
+something like this:
+
+	bundle exec tconsole
+
+	Loading your Rails environment...
+	Environment loaded in 7.160264s.
+
+	>
+
+Now that you're in the console, let's test out the `all` command!
+Running `all` from the console runs all of your unit, functional, and
+integration tests:
+
+	> all
+	Running tests...
+
+	Run options:
+
+	# Running tests:
+
+	....................................................................................
+
+	Finished tests in 6.054574s, 6.4999 tests/s, 10.5822 assertions/s.
+
+	39 tests, 45 assertions, 0 failures, 0 errors, 0 skips
+
+	Test time (including load): 82.806741s
+
+	>
+
+If you want to focus in on a particular subset of your tests, like
+units, functionals, or integration, just enter that keyword:
+
+    > units
+
+    > functionals
+
+    > integration
+
+You can also specify to run all tests in a specific class:
+
+    > UserTest
+
+You can dig a bit deeper and just run a particular test in that file as
+well:
+
+    > UserTest#test_that_user_is_healthy
+
+You can list more than just one class or class and method to run, and
+TConsole will run them all.
+
+    > UserTest InvoiceTest SubscriptionTest#test_that_renew_renews_the_subscription
+
+There are a few special ! commands that use data from past test runs.
+The `!failed` command will rerun the set of tests that failed during the
+last run:
+
+	> !failed
+
+There's also a `!timings` command that will show you a listing of your last test run's test times, sorted to help you
+improve slow tests:
+
+	> !timings
+
+	Timings from last run:
+
+	0.042632s PostTest#test_new_post_should_not_be_published
+	0.033892s PostTest#test_post_should_have_a_title
+	0.033134s PostsControllerTest#test_can_reach_all_posts
+	0.007098s PostsControllerTest#test_grabs_posts
+	0.006212s PostsControllerTest#test_displays_published_posts_by_default
+	0.006107s PostTest#test_post_cannot_have_an_empty_body
+	0.002197s PostTest#test_post_should_have_a_publish_date_set_when_published
+	0.001937s PostTest#test_post_cannot_have_an_empty_title
+	0.001232s PostTest#test_post_should_have_an_initial_state
+	0.001128s PostTest#test_post's_state_should_change_when_published
+	0.001056s PostTest#test_returning_only_published_posts
+	0.000923s PostTest#test_post_should_have_respond_to_published_appropriately
+	0.000770s PostTest#test_post_should_have_a_body
+
+You can turn on the Fail Fast feature to cause TConsole to stop running
+tests as soon as the first test fails. To enable fail fast simply enter:
+
+  > set fast on
+
+In the console. You can disable Fail Fast again with:
+
+  > set fast off
+
+If you update your environment, maybe by editing your Gemfile or
+changing one of your application's configuration files, you can use the
+`reload` command to reload the entire environment:
+
+	> reload
+
+And then finally, you can run the `exit` command to quit:
+
+	> exit
+
+Command Line Options
+-----
+
+Since TConsole is primarily meant to be run as an interactive console,
+it doesn't have many command line arguments, but there are a few.
+TConsole also passes any parameters that it doesn't know through to be
+run as its initial command. So, for example:
+
+```
+> tconsole all
+```
+
+passes `all` through as the first command to be run, so that command
+would start TConsole and immediately run all tests. There's a `--once`
+option that can be used if you'd simply like to run a single command by
+passing it to the TConsole command in then exit.
+
+The only other TConsole command line option is `--trace`. `--trace` is
+primarily useful for diagnosing problems with TConsole.
+
+
+Configuration Files
+------
+
+TConsole attempts to load a .tconsole file in your home directory and in
+your project directory, in that order, to configure your preferred
+defaults for TConsole. In many situations you won't need to edit your
+TConsole configuration files to run TConsole, because it includes a sane
+set of defaults and attempts to auto-detect Rails applications. 
+
+Here's a commented example configuration file:
+
+``` ruby
+TConsole::Config.run do |config|
+  # Configures the directory where your tests are located
+  config.test_dir = "./test"
+
+  # Include paths that should be added to Ruby's load path
+  config.include_paths = ["./test", "./lib"]
+
+  # Paths that should be preloaded. You'll have to run the reload
+  # command to reload these paths in TConsole
+  config.preload_paths = ["./config/application"]
+
+  # File sets are the named sets of files that can be executed. A file
+  # set named "all" must be included.
+  config.file_sets = {
+    "all" => ["test/**/*_test.rb"],
+    "units" => ["test/units/**/*_test.rb"]
+  }
+
+  # Fail fast specifies whether or not tests should stop executing once
+  # the first failure occurs.
+  config.fail_fast = true
+
+  # Specifies code to be run before loading the environment
+  config.before_load do
+    ENV["RAILS_ENV"] ||= "test"
+  end
+
+  # Specifies code to be run after loading the environment
+  config.after_load do
+    ::Rails.application
+    ::Rails::Engine.class_eval do
+      def eager_load!
+        # turn off eager_loading
+      end
+    end
+  end
+
+  # Specifies code to be run before each test execution
+  config.before_test_run do
+    puts "I'm about to run!!!"
+  end
+end
+```
+
+
+Reporting Issues and Contributing
+------
+
+Feel free to report issues in the issue tracker at
+https://github.com/gma/tconsole/issues. Be sure to include the versions
+of Ruby, Rails, and your operating system. For bonus points, fork the
+project and send me a pull request with the fix for the issue you're
+seeing.
+
+*How embarrassing?!?! A testing tool with no tests?* At first TConsole
+was just a bit of experimental code, so test coverage is light. I am
+working on improving that, though.
+
+License
+-----
+
+Copyright (c) 2012 Alan Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/rconsole

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), "..", "lib", "tconsole")
+
+TConsole::Runner.new(:rspec, ARGV).run

data/bin/tconsole

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), "..", "lib", "tconsole")
+
+TConsole::Runner.new(:minitest, ARGV).run

data/cibuild

@@ -0,0 +1,4 @@
+mkdir -p vendor
+bundle install --path vendor/gems --binstubs
+
+rake test

data/lib/tconsole.rb

@@ -0,0 +1,18 @@
+require "tconsole/version"
+
+require "chattyproc"
+require "optparse"
+require "readline"
+require "benchmark"
+require "term/ansicolor"
+require "shellwords"
+
+require "tconsole/config"
+require "tconsole/reporter"
+require "tconsole/console"
+require "tconsole/server"
+require "tconsole/minitest_server"
+require "tconsole/rspec_server"
+require "tconsole/test_result"
+require "tconsole/util"
+require "tconsole/runner"

data/lib/tconsole/config.rb

@@ -0,0 +1,251 @@
+module TConsole
+  class Config
+    # Lets us know if we're running rspec or minitest
+    attr_accessor :mode
+    
+    # Lets us know if we should include trace output
+    attr_accessor :trace_execution
+
+    # Lets us know if we should include trace output.
+    # Defaults to false.
+    attr_accessor :trace
+
+    # Test directory for the app we're testing.
+    # Defaults to ./test.
+    attr_accessor :test_dir
+
+    # Paths to add to the ruby include path.
+    # Defaults to ./test, ./lib
+    attr_accessor :include_paths
+
+    # Paths we want to preload. Defaults to nil.
+    attr_accessor :preload_paths
+
+    # Whether or not our test runs should stop when the first
+    # test fails. Defaults to false.
+    attr_accessor :fail_fast
+
+    # Defines the file set commands that are available
+    attr_accessor :file_sets
+
+    # Counts of tests in suites
+    attr_accessor :cached_suite_counts
+
+    # Element names we know
+    attr_accessor :cached_elements
+
+    # First command to run when tconsole loads
+    attr_accessor :run_command
+
+    # Only runs the command passed on the command line, and then exits
+    attr_accessor :once
+
+    def initialize(mode, argv = [])
+      self.mode = mode
+      
+      self.trace_execution = false
+      
+      if mode == :rspec
+        self.test_dir = "spec"
+        self.include_paths = ["./spec", "./lib"]
+      else
+        self.test_dir = "test"
+        self.include_paths = ["./test", "./lib"]
+      end
+      
+      self.preload_paths = []
+      self.fail_fast = false
+      
+      if mode == :rspec        
+        self.file_sets = {
+          "all" => ["#{test_dir}/**/*_spec.rb"]
+        }
+        
+        # build file sets dynamically based on directories under the test
+        # directory
+        sets = Dir.entries(test_dir).select {|entry| File.directory?(File.join(test_dir,entry)) and !(entry =='.' || entry == '..') }
+        sets.each do |set|
+          self.file_sets[set] = ["#{test_dir}/#{set}/**/*_spec.rb"]
+        end
+      else
+        self.file_sets = {
+          "all" => ["#{test_dir}/**/*_test.rb"]
+        }
+      end
+
+      # load any args into this config that were passed
+      load_args(argv)
+
+      @after_load = nil
+      @before_load = nil
+      @before_test_run = nil
+
+      @cached_suite_counts = {}
+      @cached_elements = {}
+    end
+    
+    # Returns the string name of our current app, i.e. tconsole or rconsole
+    def app
+      Config.app(mode)
+    end
+
+    def option_parser
+      @option_parser ||= OptionParser.new do |opts|
+        opts.on("-t", "--trace", "Enable verbose output.") do
+          self.trace_execution = true
+        end
+
+        opts.on("-o", "--once", "Run whatever command is passed and then exit.") do
+          self.once = true
+        end
+      end
+    end
+
+    # Public: Loads any passed command line arguments into the config.
+    #
+    # argv  - The array of command line arguments we're loading
+    def load_args(argv)
+      args = argv.clone
+
+      option_parser.parse!(args)
+      self.run_command = args.join(" ")
+    end
+
+    def trace?
+      self.trace_execution
+    end
+
+    def fail_fast?
+      self.fail_fast
+    end
+
+    # Code to run before loading the environment
+    def before_load(&block)
+      @before_load = block
+    end
+
+    # Calls the before load callback
+    def before_load!
+      @before_load.call unless @before_load.nil?
+    end
+
+    # Code to run after loading the environment
+    def after_load(&block)
+      @after_load = block
+    end
+
+    # Calls the after load callback
+    def after_load!
+      @after_load.call unless @after_load.nil?
+    end
+
+    # Calls before each test execution
+    def before_test_run(&block)
+      @before_test_run = block
+    end
+
+    def before_test_run!
+      @before_test_run.call unless @before_test_run.nil?
+    end
+
+    def cache_test_ids(result)
+      self.cached_suite_counts = result.suite_counts
+      self.cached_elements = result.elements
+    end
+
+    # Returns true if this config is valid or false otherwise
+    def validation_errors
+      errors = []
+
+      unless Dir.exists?(test_dir)
+        errors << "Couldn't find test directory `#{test_dir}`. Exiting."
+      end
+
+      unless file_sets.is_a?(Hash) && !file_sets["all"].nil?
+        errors << "No `all` file set is defined in your configuration. Exiting."
+      end
+
+      errors
+    end
+
+    # Loads up a config file
+    def self.load_config(path)
+      if File.exist?(path)
+        load path
+      end
+    end
+
+    # Saves a configuration block that we can apply to the configuration once it's
+    # loaded
+    def self.run(&block)
+      @loaded_configs ||= []
+      @loaded_configs << block
+    end
+
+    def self.clear_loaded_configs
+      @loaded_configs = nil
+    end
+
+    # Returns an appropriate tconsole config based on the environment
+    def self.configure(mode, argv = [])
+      config = Config.new(mode, argv)
+
+      if is_rails?
+        config.preload_paths = ["./config/application"]
+
+        if mode == :minitest
+          config.include_paths = ["./test"]
+          config.file_sets = {
+            "all" => [
+              "#{config.test_dir}/controllers/**/*_test.rb",
+              "#{config.test_dir}/decorators/**/*_test.rb",
+              "#{config.test_dir}/helpers/**/*_test.rb",
+              "#{config.test_dir}/mailers/**/*_test.rb",
+              "#{config.test_dir}/models/**/*_test.rb"
+            ],
+            "models" => ["#{config.test_dir}/models/**/*_test.rb"],
+            "decorators" => ["#{config.test_dir}/decorators/**/*_test.rb"],
+            "controllers" => ["#{config.test_dir}/controllers/**/*_test.rb"],
+            "integration" => ["#{config.test_dir}/integration/**/*_test.rb"]
+          }
+        end
+
+        config.before_load do
+          ENV["RAILS_ENV"] ||= "test"
+        end
+
+        config.after_load do
+          ::Rails.application
+          ::Rails::Engine.class_eval do
+            def eager_load!
+              # turn off eager_loading
+            end
+          end
+        end
+
+        config.before_test_run do
+          if defined? ::ActiveRecord
+            ::ActiveRecord::Base.clear_active_connections!
+            ::ActiveRecord::Base.establish_connection
+          end
+        end
+      end
+
+      @loaded_configs ||= []
+      @loaded_configs.each do |block|
+        block.call(config)
+      end
+
+      config
+    end
+
+    def self.is_rails?
+      @rails ||= !!File.exist?("./config/application.rb")
+    end
+    
+    # Public: Returns the app name based on the given mode.
+    def self.app(mode)
+      mode == :minitest ? "tconsole" : "rconsole"
+    end
+  end
+end