kicker 2.1.0 → 2.2.0

data/test/log_status_helper_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Kicker::LogStatus" do
+  yielded = nil
+  
+  before do
+    @status = Kicker::LogStatusHelper.new(proc { |s| yielded = s; 'out' if s.growl? }, 'ls -l')
+  end
+  
+  it "should return whether or not it's for a stdout logger" do
+    @status.call(:stdout)
+    yielded.should.be.stdout
+    yielded.should.not.be.growl
+  end
+  
+  it "should return whether or not it's for a growl logger" do
+    @status.call(:growl)
+    yielded.should.not.be.stdout
+    yielded.should.be.growl
+  end
+  
+  it "should return the command" do
+    @status.call(:growl)
+    yielded.command.should == 'ls -l'
+  end
+  
+  it "should return if it's before executing the command" do
+    @status.call(:growl)
+    yielded.should.be.before
+    yielded.should.be.not.after
+  end
+  
+  it "should return if it's after executing the command" do
+    @status.result('output', true, 0)
+    @status.call(:growl)
+    yielded.should.not.be.before
+    yielded.should.be.after
+  end
+  
+  it "should return the output and status" do
+    @status.result('output', true, 123)
+    @status.call(:growl)
+    yielded.output.should == "output"
+    yielded.should.be.success
+    yielded.exit_code.should.be 123
+  end
+  
+  it "should set the logger type, call the proc with self, and return the output" do
+    @status.call(:growl).should == "out"
+  end
+  
+  it "should not try to call the block if none was given and return nil" do
+    status = Kicker::LogStatusHelper.new(nil, 'ls -l')
+    status.call(:growl).should.be nil
+  end
+end

data/test/options_test.rb

@@ -1,30 +1,68 @@
 require File.expand_path('../test_helper', __FILE__)
 
-describe "Kicker.parse_options" do
+describe "Kicker::Options.parse" do
+  after do
+    Kicker.latency = 1
+    Kicker.paths = %w{ . }
+    Kicker.silent = false
+    Kicker.quiet = false
+    Kicker::Growl.use = true
+    Kicker::Growl.command = nil
+  end
+  
   it "should parse the paths" do
-    Kicker.parse_options([])[:paths].should.be nil
+    Kicker::Options.parse([])
+    Kicker.paths.should == %w{ . }
+    
+    Kicker::Options.parse(%w{ /some/file.rb })
+    Kicker.paths.should == %w{ /some/file.rb }
     
-    Kicker.parse_options(%w{ /some/file.rb })[:paths].should == %w{ /some/file.rb }
-    Kicker.parse_options(%w{ /some/file.rb /a/dir /and/some/other/file.rb })[:paths].should ==
-      %w{ /some/file.rb /a/dir /and/some/other/file.rb }
+    Kicker::Options.parse(%w{ /some/file.rb /a/dir /and/some/other/file.rb })
+    Kicker.paths.should == %w{ /some/file.rb /a/dir /and/some/other/file.rb }
   end
   
   it "should parse if growl shouldn't be used" do
-    Kicker.parse_options([])[:growl].should == true
-    Kicker.parse_options(%w{ --no-growl })[:growl].should == false
+    Kicker::Options.parse([])
+    Kicker::Growl.should.use
+    
+    Kicker::Options.parse(%w{ --no-growl })
+    Kicker::Growl.should.not.use
+  end
+  
+  it "should parse if we should keep output to a minimum" do
+    Kicker::Options.parse([])
+    Kicker.should.not.be.silent
+    
+    Kicker::Options.parse(%w{ -s })
+    Kicker.should.be.silent
+  end
+  
+  it 'should parse whether or not to run in quiet mode and enable silent mode if quiet' do
+    Kicker::Options.parse([])
+    Kicker.should.not.be.quiet
+    Kicker.should.not.be.silent
+    
+    Kicker::Options.parse(%w{ --quiet })
+    Kicker.should.be.quiet
+    Kicker.should.be.silent
   end
   
   it "should parse the Growl command to use when the user clicks the Growl succeeded message" do
-    Kicker.parse_options(%w{ --growl-command ls })[:growl_command].should == 'ls'
+    Kicker::Options.parse(%w{ --growl-command ls })
+    Kicker::Growl.command.should == 'ls'
   end
   
   it "should parse the latency to pass to FSEvents" do
-    Kicker.parse_options(%w{ -l 2.5 })[:latency].should == 2.5
-    Kicker.parse_options(%w{ --latency 3.5 })[:latency].should == 3.5
+    Kicker::Options.parse(%w{ -l 2.5 })
+    Kicker.latency.should == 2.5
+    
+    Kicker::Options.parse(%w{ --latency 3.5 })
+    Kicker.latency.should == 3.5
   end
   
   it "should parse recipe requires" do
-    Kicker.parse_options(%w{ -r rails -r jstest })[:recipes].should == %w{ rails jstest }
-    Kicker.parse_options(%w{ --recipe rails --recipe jstest })[:recipes].should == %w{ rails jstest }
+    Kicker::Recipes.expects(:recipe).with('rails')
+    Kicker::Recipes.expects(:recipe).with('jstest')
+    Kicker::Options.parse(%w{ -r rails --recipe jstest })
   end
 end

data/test/recipes/could_not_handle_file_test.rb

@@ -1,6 +1,10 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 describe "Kicker, concerning the default `could not handle file' callback" do
+  after do
+    Kicker.silent = false
+  end
+  
   it "should log that it could not handle the given files" do
     Kicker::Utils.expects(:log).with('')
     Kicker::Utils.expects(:log).with("Could not handle: /file/1, /file/2")
@@ -8,4 +12,10 @@ describe "Kicker, concerning the default `could not handle file' callback" do
     
     Kicker.post_process_chain.last.call(%w{ /file/1 /file/2 })
   end
+  
+  it "should not log in silent mode" do
+    Kicker.silent = true
+    Kicker::Utils.expects(:log).never
+    Kicker.post_process_chain.last.call(%w{ /file/1 /file/2 })
+  end
 end

data/test/recipes/dot_kick_test.rb

@@ -1,9 +1,5 @@
 require File.expand_path('../../test_helper', __FILE__)
 
-before = Kicker.process_chain.dup
-require 'kicker/recipes/dot_kick'
-DOT_KICK = (Kicker.process_chain - before).first
-
 describe "The .kick handler" do
   it "should reset $LOADED_FEATURES and callback chains to state before loading .kick and reload .kick" do
     ReloadDotKick.save_state
@@ -16,7 +12,7 @@ describe "The .kick handler" do
     2.times do
       require File.expand_path('../../fixtures/a_file_thats_reloaded', __FILE__)
       process {}
-      DOT_KICK.call(%w{ .kick })
+      ReloadDotKick.call(%w{ .kick })
     end
     
     $FROM_RELOADED_FILE.should == 2

data/test/recipes/execute_cli_command_test.rb

@@ -4,15 +4,15 @@ describe "Kicker, concerning the `execute a command-line' callback" do
   it "should parse the command and add the callback" do
     before = Kicker.pre_process_chain.length
     
-    Kicker.parse_options(%w{ -e ls })
+    Kicker::Options.parse(%w{ -e ls })
     Kicker.pre_process_chain.length.should == before + 1
     
-    Kicker.parse_options(%w{ --execute ls })
+    Kicker::Options.parse(%w{ --execute ls })
     Kicker.pre_process_chain.length.should == before + 2
   end
   
   it "should call execute with the given command" do
-    Kicker.parse_options(%w{ -e ls })
+    Kicker::Options.parse(%w{ -e ls })
     
     callback = Kicker.pre_process_chain.last
     callback.should.be.instance_of Proc

data/test/recipes/ignore_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 before = Kicker.pre_process_chain.dup
-require 'kicker/recipes/ignore'
+recipe :ignore
 IGNORE = (Kicker.pre_process_chain - before).first
 
 describe "The Ignore handler" do

data/test/recipes/jstest_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 before = Kicker.process_chain.dup
-require 'kicker/recipes/jstest'
+recipe :jstest
 JSTEST = (Kicker.process_chain - before).first
 
 describe "The HeadlessSquirrel handler" do

data/test/recipes/rails_test.rb

@@ -1,24 +1,62 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 before = Kicker.process_chain.dup
-require 'kicker/recipes/rails'
-RAILS = (Kicker.process_chain - before).first
+recipe :rails
+RAILS_FILES, RAILS_SCHEMA = (Kicker.process_chain - before).first(2)
 
 describe "The Rails helper module" do
-  it "should return all functional tests" do
+  after do
+    Ruby.test_type = nil
+    Ruby.test_cases_root = nil
+  end
+  
+  it "should return all controller tests when test_type is `test'" do
     Dir.expects(:glob).with("test/functional/**/*_test.rb").returns(%w{ test.rb })
-    Rails.all_functional_tests.should == %w{ test.rb }
+    Rails.all_controller_tests.should == %w{ test.rb }
+  end
+  
+  it "should return all controller tests when test_type is `spec'" do
+    Ruby.test_type = 'spec'
+    Ruby.test_cases_root = nil
+    
+    Dir.expects(:glob).with("spec/controllers/**/*_spec.rb").returns(%w{ spec.rb })
+    Rails.all_controller_tests.should == %w{ spec.rb }
   end
 end
 
-describe "The rails handler" do
-  before do
-    @files = %w{ Rakefile }
+describe "The misc Rails handlers" do
+  it "should prepare the test database if db/schema.rb is modified" do
+    Kicker::Utils.expects(:execute).with('rake db:test:prepare')
+    RAILS_SCHEMA.call(%w{ db/schema.rb })
   end
   
-  it "should match any test case files" do
-    should_match %w{ test/1_test.rb test/namespace/2_test.rb },
-                 %w{ test/1_test.rb test/namespace/2_test.rb }
+  it "should not prepare the test database if another file than db/schema.rb is modified" do
+    Kicker::Utils.expects(:execute).never
+    RAILS_SCHEMA.call(%w{ Rakefile })
+  end
+end
+
+module SharedRailsHandlerHelper
+  def should_match(files, tests)
+    @files += files
+    
+    tests.each do |test|
+      File.stubs(:exist?).with(test).returns(true)
+    end
+    
+    Rails.expects(:run_tests).with(tests)
+    RAILS_FILES.call(@files)
+    @files.should == %w{ Rakefile }
+  end
+end
+
+describe "An instance of the Rails handler, with test type `test'" do
+  include SharedRailsHandlerHelper
+  
+  before do
+    Ruby.test_type = 'test'
+    File.stubs(:exist?).with('spec').returns(false)
+    @files = %w{ Rakefile }
   end
   
   it "should map model files to test/unit" do
@@ -48,7 +86,7 @@ describe "The rails handler" do
   
   it "should run all functional tests when config/routes.rb is saved" do
     tests = %w{ test/functional/members_controller_test.rb test/functional/admin/articles_controller_test.rb }
-    Rails.expects(:all_functional_tests).returns(tests)
+    Rails.expects(:all_controller_tests).returns(tests)
     should_match %w{ config/routes.rb }, tests
   end
   
@@ -57,17 +95,79 @@ describe "The rails handler" do
                  %w{ test/lib/money_test.rb test/lib/views/date_test.rb }
   end
   
-  private
-  
-  def should_match(files, tests)
-    @files += files
+  it "should map fixtures to their unit, helper and functional tests if they exist" do
+    tests = %w{ test/unit/member_test.rb test/unit/helpers/members_helper_test.rb test/functional/members_controller_test.rb }
+    File.stubs(:exist?).returns(false)
     
+    expected_tests = []
     tests.each do |test|
+      expected_tests << test
       File.stubs(:exist?).with(test).returns(true)
+      should_match %w{ test/fixtures/members.yml }, expected_tests
     end
+  end
+end
+
+describe "An instance of the Rails handler, with test type `spec'" do
+  include SharedRailsHandlerHelper
+  
+  before do
+    Ruby.test_type = Ruby.runner_bin = Ruby.test_cases_root = nil
+    File.stubs(:exist?).with('spec').returns(true)
+    @files = %w{ Rakefile }
+  end
+  
+  it "should map model files to spec/models" do
+    should_match %w{ app/models/member.rb       app/models/article.rb },
+                 %w{ spec/models/member_spec.rb spec/models/article_spec.rb }
+  end
+  
+  it "should map concern files to spec/models/concerns" do
+    should_match %w{ app/concerns/authenticate.rb              app/concerns/nested_resource.rb },
+                 %w{ spec/models/concerns/authenticate_spec.rb spec/models/concerns/nested_resource_spec.rb }
+  end
+  
+  it "should map helper files to spec/helpers" do
+    should_match %w{ app/helpers/members_helper.rb       app/helpers/articles_helper.rb },
+                 %w{ spec/helpers/members_helper_spec.rb spec/helpers/articles_helper_spec.rb }
+  end
+  
+  it "should map controller files to spec/controllers" do
+    should_match %w{ app/controllers/application_controller.rb       app/controllers/members_controller.rb },
+                 %w{ spec/controllers/application_controller_spec.rb spec/controllers/members_controller_spec.rb }
+  end
+  
+  it "should map view templates to spec/controllers" do
+    should_match %w{ app/views/members/index.html.erb            app/views/admin/articles/show.html.erb },
+                 %w{ spec/controllers/members_controller_spec.rb spec/controllers/admin/articles_controller_spec.rb }
+  end
+  
+  it "should run all controller tests when config/routes.rb is saved" do
+    specs = %w{ spec/controllers/members_controller_test.rb spec/controllers/admin/articles_controller_test.rb }
+    Rails.expects(:all_controller_tests).returns(specs)
+    should_match %w{ config/routes.rb }, specs
+  end
+  
+  it "should map lib files to spec/lib" do
+    should_match %w{ lib/money.rb           lib/views/date.rb },
+                 %w{ spec/lib/money_spec.rb spec/lib/views/date_spec.rb }
+  end
+  
+  it "should map fixtures to their model, helper and controller specs" do
+    specs = %w{ spec/models/member_spec.rb spec/helpers/members_helper_spec.rb spec/controllers/members_controller_spec.rb }
+    should_match %w{ spec/fixtures/members.yml }, specs
+  end
+  
+  it "should map fixtures to their model, helper and controller specs if they exist" do
+    Ruby.test_type = 'spec'
+    specs = %w{ spec/models/member_spec.rb spec/helpers/members_helper_spec.rb spec/controllers/members_controller_spec.rb }
+    File.stubs(:exist?).returns(false)
     
-    Kicker::Utils.expects(:run_ruby_tests).with(tests)
-    RAILS.call(@files)
-    @files.should == %w{ Rakefile }
+    expected_specs = []
+    specs.each do |spec|
+      expected_specs << spec
+      File.stubs(:exist?).with(spec).returns(true)
+      should_match %w{ spec/fixtures/members.yml }, expected_specs
+    end
   end
 end

data/test/recipes/ruby_test.rb

@@ -0,0 +1,154 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+before = Kicker.process_chain.dup
+recipe :ruby
+RUBY_FILES = (Kicker.process_chain - before).first
+
+class Ruby
+  def self.execute(command, &block)
+    @block = block
+  end
+  
+  def self.execute_block
+    @block
+  end
+end
+
+describe "The Ruby handler" do
+  before do
+    Ruby.test_type = nil
+    Ruby.runner_bin = nil
+    Ruby.test_options = []
+  end
+  
+  after do
+    Ruby.test_type = 'test'
+    Ruby.runner_bin = nil
+    Ruby.test_options = []
+  end
+  
+  it "should instantiate a Ruby instance" do
+    handler = mock('Ruby', :handle! => nil, :tests => %w{ test/1_test.rb test/namespace/2_test.rb })
+    Ruby.expects(:new).with(%w{ test/1_test.rb Rakefile test/namespace/2_test.rb }).returns(handler)
+    Ruby.expects(:run_tests).with(%w{ test/1_test.rb test/namespace/2_test.rb })
+    RUBY_FILES.call(%w{ test/1_test.rb Rakefile test/namespace/2_test.rb })
+  end
+  
+  it "should discover whether to use `ruby' or `spec' as the test_type" do
+    File.expects(:exist?).with('spec').returns(false)
+    Ruby.test_type.should == 'test'
+    
+    Ruby.test_type = nil
+    File.expects(:exist?).with('spec').returns(true)
+    Ruby.test_type.should == 'spec'
+  end
+  
+  it "should run the given tests with a test-unit runner" do
+    Ruby.expects(:execute).with("ruby  -r test/1_test.rb -r test/namespace/2_test.rb -e ''")
+    Ruby.run_tests(%w{ test/1_test.rb test/namespace/2_test.rb })
+  end
+  
+  it "should run the given tests with a spec runner" do
+    Ruby.stubs(:test_type).returns('spec')
+    Ruby.expects(:execute).with("spec  spec/1_spec.rb spec/namespace/2_spec.rb")
+    Ruby.run_tests(%w{ spec/1_spec.rb spec/namespace/2_spec.rb })
+  end
+  
+  it "should not try to run the tests if none were given" do
+    Ruby.expects(:execute).never
+    Ruby.run_tests([])
+  end
+  
+  it "should be possible to override the bin path" do
+    Ruby.runner_bin = '/some/other/runner'
+    Ruby.expects(:execute).with("/some/other/runner  -r test/1_test.rb -r test/namespace/2_test.rb -e ''")
+    Ruby.run_tests(%w{ test/1_test.rb test/namespace/2_test.rb })
+  end
+  
+  it "should set the alternative ruby bin path" do
+    Kicker::Options.parse(%w{ -b /opt/ruby-1.9.2/bin/ruby })
+    Ruby.runner_bin.should == '/opt/ruby-1.9.2/bin/ruby'
+    
+    Ruby.runner_bin = nil
+    Kicker::Options.parse(%w{ --ruby /opt/ruby-1.9.2/bin/ruby })
+    Ruby.runner_bin.should == '/opt/ruby-1.9.2/bin/ruby'
+  end
+  
+  it "should be possible to add runner options when test_type is `test'" do
+    Ruby.test_type = 'test'
+    Ruby.test_options << '-I ./other'
+    Ruby.expects(:execute).with("ruby -I ./other -r test/1_test.rb -e ''")
+    Ruby.run_tests(%w{ test/1_test.rb })
+  end
+  
+  it "should be possible to add runner options when test_type is `spec'" do
+    Ruby.test_type = 'spec'
+    Ruby.test_options << '-I ./other'
+    Ruby.expects(:execute).with("spec -I ./other spec/1_spec.rb")
+    Ruby.run_tests(%w{ spec/1_spec.rb })
+  end
+  
+  it "should only show the last line of the output when growling when running test_type is `test'" do
+    Ruby.run_with_test_runner(%w{ test/1_test.rb test/namespace/2_test.rb })
+    result = Ruby.execute_block.call(mock('status', :output => "foo\nall pass", :after? => true, :growl? => true))
+    result.should == 'all pass'
+  end
+  
+  it "should only show the last line of the output when growling when running test_type is `spec'" do
+    Ruby.run_with_spec_runner(%w{ spec/1_spec.rb spec/namespace/2_spec.rb })
+    result = Ruby.execute_block.call(mock('status', :output => "foo\nall pass", :after? => true, :growl? => true))
+    result.should == 'all pass'
+  end
+end
+
+%w{ test spec }.each do |type|
+  describe "An instance of the Ruby handler, with test type `#{type}'" do
+    before do
+      Ruby.stubs(:test_type).returns(type)
+      Ruby.stubs(:test_cases_root).returns(type)
+      File.stubs(:exist?).with("#{type}/1_#{type}.rb").returns(true)
+      File.stubs(:exist?).with("#{type}/namespace/2_#{type}.rb").returns(true)
+    end
+    
+    it "should match any test case files" do
+      files = %W{ Rakefile #{type}/1_#{type}.rb #{type}/namespace/2_#{type}.rb }
+      handler = Ruby.new(files)
+      handler.handle!
+      
+      handler.tests.should == %W{ #{type}/1_#{type}.rb #{type}/namespace/2_#{type}.rb }
+      files.should == %W{ Rakefile }
+    end
+    
+    it "should match files in ./lib" do
+      files = %W{ Rakefile lib/1.rb lib/namespace/2.rb }
+      handler = Ruby.new(files)
+      handler.handle!
+      
+      handler.tests.should == %W{ #{type}/1_#{type}.rb #{type}/namespace/2_#{type}.rb }
+      files.should == %w{ Rakefile }
+    end
+    
+    it "should match lib tests in the test root as well" do
+      File.stubs(:exist?).with("#{type}/namespace/2_#{type}.rb").returns(false)
+      File.stubs(:exist?).with("#{type}/2_#{type}.rb").returns(true)
+      
+      files = %W{ Rakefile lib/1.rb lib/namespace/2.rb }
+      handler = Ruby.new(files)
+      handler.handle!
+      
+      handler.tests.should == %W{ #{type}/1_#{type}.rb #{type}/2_#{type}.rb }
+      files.should == %W{ Rakefile }
+    end
+    
+    it "should check if a different test case root" do
+      Ruby.stubs(:test_cases_root).returns('test/cases')
+      
+      files = %W{ Rakefile test/cases/1_#{type}.rb test/cases/namespace/2_#{type}.rb }
+      handler = Ruby.new(files)
+      handler.handle!
+      
+      handler.tests.should == %W{ test/cases/1_#{type}.rb test/cases/namespace/2_#{type}.rb }
+      files.should == %W{ Rakefile }
+    end
+  end
+end