testbot 0.5.2 → 0.5.3

data/test/shared/adapters/helpers/test_ruby_env.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../lib/shared/adapters/helpers/ruby_env.rb'))
+require 'test/unit'
+require 'shoulda'
+require 'flexmock/test_unit'
+
+class RubyEnvTest < Test::Unit::TestCase
+  
+  context "self.bundler?" do
+
+    should "return true if bundler is installed and there is a Gemfile" do
+      flexmock(Gem).should_receive(:available?).with("bundler").once.and_return(true)
+      flexmock(File).should_receive(:exists?).with("path/to/project/Gemfile").once.and_return(true)
+      assert_equal true, RubyEnv.bundler?("path/to/project")
+    end
+
+    should "return false if bundler is installed but there is no Gemfile" do
+      flexmock(Gem).should_receive(:available?).with("bundler").once.and_return(true)
+      flexmock(File).should_receive(:exists?).and_return(false)
+      assert_equal false, RubyEnv.bundler?("path/to/project")
+    end
+
+    should "return false if bundler is not installed" do
+      flexmock(Gem).should_receive(:available?).with("bundler").once.and_return(false)
+      assert_equal false, RubyEnv.bundler?("path/to/project")
+    end
+
+  end
+
+  context "self.ruby_command" do
+    
+    should "use ruby by default" do
+      flexmock(RubyEnv).should_receive(:bundler?).and_return(false)
+      flexmock(File).should_receive(:exists?).and_return(false)
+      assert_equal 'ruby -S rspec', RubyEnv.ruby_command("path/to/project", :script => "script/spec", :bin => "rspec")
+    end
+    
+    should "use bundler when available and use the binary when there is no script" do
+      flexmock(RubyEnv).should_receive(:bundler?).once.with("path/to/project").and_return(true)
+      flexmock(File).should_receive(:exists?).with("path/to/project/script/spec").and_return(false)
+      assert_equal 'ruby -S bundle exec rspec', RubyEnv.ruby_command("path/to/project", :script => "script/spec", :bin => "rspec")  
+    end
+
+    should "use the script when it exists when using bundler" do
+      flexmock(RubyEnv).should_receive(:bundler?).and_return(true)
+      flexmock(File).should_receive(:exists?).and_return(true)
+      assert_equal 'ruby -S bundle exec script/spec', RubyEnv.ruby_command("path/to/project", :script => "script/spec", :bin => "rspec")  
+    end
+
+    should "use the script when it exists when not using bundler" do
+      flexmock(RubyEnv).should_receive(:bundler?).and_return(false)
+      flexmock(File).should_receive(:exists?).and_return(true)
+      assert_equal 'ruby -S script/spec', RubyEnv.ruby_command("path/to/project", :script => "script/spec", :bin => "rspec")  
+    end
+
+    should "be able to use jruby" do
+      flexmock(RubyEnv).should_receive(:bundler?).and_return(false)
+      flexmock(File).should_receive(:exists?).and_return(true)
+      assert_equal 'jruby -S script/spec', RubyEnv.ruby_command("path/to/project", :script => "script/spec",
+                                                                :bin => "rspec", :ruby_interpeter => "jruby")
+    end
+
+    should "be able to use jruby with bundler" do
+      flexmock(RubyEnv).should_receive(:bundler?).and_return(true)
+      flexmock(File).should_receive(:exists?).and_return(true)
+      assert_equal 'jruby -S bundle exec script/spec', RubyEnv.ruby_command("path/to/project", :script => "script/spec",
+                                                                            :bin => "rspec", :ruby_interpeter => "jruby")
+    end
+
+    should "use the interpeter when there is no binary specified" do
+      flexmock(RubyEnv).should_receive(:bundler?).and_return(true)
+      flexmock(File).should_receive(:exists?).and_return(false)
+      assert_equal 'ruby -S bundle exec ruby', RubyEnv.ruby_command("path/to/project")
+    end
+  end
+
+end

data/test/shared/adapters/test_adapter.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../lib/shared/adapters/adapter.rb'))
+require 'test/unit'
+require 'shoulda'
+
+class AdapterTest < Test::Unit::TestCase
+  
+  should "be able to find the adapters" do
+    assert_equal RSpecAdapter, Adapter.find(:spec)
+    assert_equal CucumberAdapter, Adapter.find(:features)
+    assert_equal TestUnitAdapter, Adapter.find(:test)
+  end
+  
+  should "find be able to find an adapter by string" do
+    assert_equal RSpecAdapter, Adapter.find("spec") 
+  end
+  
+  should "return be able to all types" do
+    assert_equal [ RSpecAdapter, CucumberAdapter, TestUnitAdapter ], Adapter.all
+  end
+  
+end

data/test/shared/test_testbot.rb

@@ -0,0 +1,185 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../lib/shared/testbot')) unless defined?(Testbot)
+require 'test/unit'
+require 'shoulda'
+require 'flexmock/test_unit'
+require 'sinatra'
+require File.expand_path(File.join(File.dirname(__FILE__), '../../lib/requester/requester'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../../lib/server/server'))
+
+module Testbot
+
+  module TestHelpers
+
+    def requester_attributes
+      { :server_host => "192.168.0.100",
+        :rsync_path => nil,
+        :rsync_ignores => '', :server_user => nil, :available_runner_usage => nil,
+        :project => nil, :ssh_tunnel => nil }
+    end  
+  
+  end
+
+  class CLITest < Test::Unit::TestCase
+    
+    include TestHelpers
+    
+    context "self.run" do
+
+      context "with no args" do
+        should "return false" do
+          assert_equal false, CLI.run([])
+        end   
+      end
+    
+      context "with --help" do
+        should "return false" do
+          assert_equal false, CLI.run([ '--help' ])
+        end      
+      end
+    
+      context "with --version" do
+        should "print version and return true" do
+          flexmock(CLI).should_receive(:puts).once.with("Testbot #{Testbot.version}")
+          assert_equal true, CLI.run([ '--version' ])
+        end
+      end
+        
+      context "with --server" do
+        should "start a server" do
+          flexmock(SimpleDaemonize).should_receive(:stop).once.with(Testbot::SERVER_PID)
+          flexmock(SimpleDaemonize).should_receive(:start).once.with(any, Testbot::SERVER_PID, "testbot (server)")
+          flexmock(CLI).should_receive(:puts).once.with("Testbot server started (pid: #{Process.pid})")
+          assert_equal true, CLI.run([ "--server" ])
+        end
+      
+        should "start a server when start is passed" do
+          flexmock(SimpleDaemonize).should_receive(:stop).once.with(Testbot::SERVER_PID)
+          flexmock(SimpleDaemonize).should_receive(:start).once
+          flexmock(CLI).should_receive(:puts)
+          assert_equal true, CLI.run([ "--server", "start" ])
+        end
+    
+        should "stop a server when stop is passed" do
+          flexmock(SimpleDaemonize).should_receive(:stop).once.with(Testbot::SERVER_PID).and_return(true)
+          flexmock(CLI).should_receive(:puts).once.with("Testbot server stopped")
+          assert_equal true, CLI.run([ "--server", "stop" ])
+        end
+    
+        should "not print when SimpleDaemonize.stop returns false" do
+          flexmock(SimpleDaemonize).should_receive(:stop).and_return(false)
+          flexmock(CLI).should_receive(:puts).never
+          CLI.run([ "--stop", "server" ])
+        end
+      
+        should "start it in the foreground with run" do
+          flexmock(SimpleDaemonize).should_receive(:stop).once.with(Testbot::SERVER_PID)
+          flexmock(SimpleDaemonize).should_receive(:start).never
+          flexmock(Sinatra::Application).should_receive(:run!).once.with(:environment => "production")
+          assert_equal true, CLI.run([ "--server", 'run' ])
+        end
+      end
+  
+      context "with --runner" do
+        should "start a runner" do
+          flexmock(SimpleDaemonize).should_receive(:stop).once.with(Testbot::RUNNER_PID)
+          flexmock(SimpleDaemonize).should_receive(:start).once.with(any, Testbot::RUNNER_PID, "testbot (runner)")
+          flexmock(CLI).should_receive(:puts).once.with("Testbot runner started (pid: #{Process.pid})")
+          assert_equal true, CLI.run([ "--runner", "--connect", "192.168.0.100", "--working_dir", "/tmp/testbot" ])
+        end
+      
+        should "start a runner when start is passed" do
+          flexmock(SimpleDaemonize).should_receive(:stop).once.with(Testbot::RUNNER_PID)
+          flexmock(SimpleDaemonize).should_receive(:start).once
+          flexmock(CLI).should_receive(:puts)
+          assert_equal true, CLI.run([ "--runner", "start", "--connect", "192.168.0.100" ])
+        end
+      
+        should "stop a runner when stop is passed" do
+          flexmock(SimpleDaemonize).should_receive(:stop).once.with(Testbot::RUNNER_PID).and_return(true)
+          flexmock(CLI).should_receive(:puts).once.with("Testbot runner stopped")
+          assert_equal true, CLI.run([ "--runner", "stop" ])
+        end
+      
+        should "return false without connect" do
+          assert_equal false, CLI.run([ "--runner", "--connect" ])
+          assert_equal false, CLI.run([ "--runner" ])
+        end
+      
+        should "start it in the foreground with run" do
+          flexmock(SimpleDaemonize).should_receive(:stop).once.with(Testbot::RUNNER_PID)
+          flexmock(SimpleDaemonize).should_receive(:start).never
+          flexmock(Runner::Runner).should_receive(:new).once.and_return(mock = Object.new)
+          flexmock(mock).should_receive(:run!).once
+          assert_equal true, CLI.run([ "--runner", 'run', '--connect', '192.168.0.100' ])
+        end
+      end
+    
+      Adapter.all.each do |adapter|
+        context "with --#{adapter.type}" do
+          should "start a #{adapter.name} requester and return true" do
+            flexmock(Requester::Requester).should_receive(:new).once.
+                                           with(requester_attributes).and_return(mock = Object.new)
+            flexmock(mock).should_receive(:run_tests).once.with(adapter, adapter.base_path)
+            assert_equal true, CLI.run([ "--#{adapter.type}", "--connect", "192.168.0.100" ])
+          end
+        
+          should "accept a custom rsync_path" do
+            flexmock(Requester::Requester).should_receive(:new).once.
+                                           with(requester_attributes.merge({ :rsync_path => "/somewhere/else" })).
+                                           and_return(mock = Object.new)
+            flexmock(mock).should_receive(:run_tests)
+            CLI.run([ "--#{adapter.type}", "--connect", "192.168.0.100", '--rsync_path', '/somewhere/else' ])
+          end
+        
+          should "accept rsync_ignores" do
+            flexmock(Requester::Requester).should_receive(:new).once.
+                                           with(requester_attributes.merge({ :rsync_ignores => "tmp log" })).
+                                           and_return(mock = Object.new)
+            flexmock(mock).should_receive(:run_tests)
+            CLI.run([ "--#{adapter.type}", "--connect", "192.168.0.100", '--rsync_ignores', 'tmp', 'log' ])
+          end
+        
+          should "accept ssh tunnel" do
+            flexmock(Requester::Requester).should_receive(:new).once.
+                                           with(requester_attributes.merge({ :ssh_tunnel => true })).
+                                           and_return(mock = Object.new)
+            flexmock(mock).should_receive(:run_tests)
+            CLI.run([ "--#{adapter.type}", "--connect", "192.168.0.100", '--ssh_tunnel' ])
+          end
+          
+          should "accept a custom user" do
+            flexmock(Requester::Requester).should_receive(:new).once.
+                                           with(requester_attributes.merge({ :server_user => "cruise" })).
+                                           and_return(mock = Object.new)
+            flexmock(mock).should_receive(:run_tests)
+            CLI.run([ "--#{adapter.type}", "--connect", "192.168.0.100", '--user', 'cruise' ])
+          end
+          
+          should "accept a custom project name" do
+            flexmock(Requester::Requester).should_receive(:new).once.
+                                           with(requester_attributes.merge({ :project => "rspec" })).
+                                           and_return(mock = Object.new)
+            flexmock(mock).should_receive(:run_tests)
+            CLI.run([ "--#{adapter.type}", "--connect", "192.168.0.100", '--project', 'rspec' ])
+          end
+        end
+      end
+    end
+    
+    context "self.parse_args" do
+
+      should 'convert ARGV arguments to a hash' do
+        hash = CLI.parse_args("--runner --connect http://127.0.0.1:#{Testbot::SERVER_PORT} --working_dir ~/testbot --ssh_tunnel user@testbot_server".split)
+        assert_equal ({ :runner => true, :connect => "http://127.0.0.1:#{Testbot::SERVER_PORT}", :working_dir => "~/testbot", :ssh_tunnel => "user@testbot_server" }), hash
+      end
+    
+      should "handle just a key without a value" do
+        hash = CLI.parse_args([ "--server" ])
+        assert_equal ({ :server => true }), hash
+      end
+    
+    end
+  
+  end
+  
+end

data/test/test_integration.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'test/unit'
+require 'fileutils'
+require 'shoulda'
+
+class IntegrationTest < Test::Unit::TestCase
+
+  def stop!
+    system "export INTEGRATION_TEST=true; bin/testbot --server stop > /dev/null"
+    system "export INTEGRATION_TEST=true; bin/testbot --runner stop > /dev/null"
+  end
+
+  # This is slow, and Test:Unit does not have "before/after :all" method, so I'm using a single testcase for multiple tests
+  should "be able to send a build request, have it run and show the results" do
+    Thread.new {
+
+      sleep 30
+      puts "Still running after 30 secs, stopping..."
+      stop!
+    }
+
+    system "rm -rf tmp; mkdir -p tmp; cp -rf test/fixtures/local tmp/local"
+    system "export INTEGRATION_TEST=true; bin/testbot --runner --connect 127.0.0.1 --working_dir tmp/runner > /dev/null"
+    system "export INTEGRATION_TEST=true; bin/testbot --server > /dev/null"
+     
+    # For debug
+    # Thread.new do
+    #   system "export INTEGRATION_TEST=true; bin/testbot --runner run --connect 127.0.0.1 --working_dir tmp/runner"
+    # end
+    # Thread.new do
+    #   system "export INTEGRATION_TEST=true; bin/testbot --server run"
+    # end
+
+    sleep 2.0
+    result = `cd tmp/local; INTEGRATION_TEST=true ../../bin/testbot --spec --connect 127.0.0.1 --rsync_path ../server --rsync_ignores "log/* tmp/*"`
+  
+    # Should include the result from script/spec
+    #puts result.inspect
+    assert result.include?('script/spec got called with ["-O", "spec/spec.opts", "spec/models/house_spec.rb", "spec/models/car_spec.rb"]') ||
+           result.include?('script/spec got called with ["-O", "spec/spec.opts", "spec/models/car_spec.rb", "spec/models/house_spec.rb"]')           
+    
+
+    # Should not include ignored files
+    assert !File.exists?("tmp/server/log/test.log")
+    assert !File.exists?("tmp/server/tmp/restart.txt")
+    assert !File.exists?("tmp/runner/local/log/test.log")
+    assert !File.exists?("tmp/runner/local/tmp/restart.txt")
+  end
+  
+  def teardown
+    stop!
+    FileUtils.rm_rf "tmp"
+  end
+
+end

data/testbot.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.description = %q{Testbot is a test distribution tool that works with Rails, RSpec, Test::Unit and Cucumber.}
   s.bindir      = "bin"
   s.executables = [ "testbot" ]
-  s.files       = Dir.glob("lib/**/*") + %w(Gemfile .gemtest testbot.gemspec CHANGELOG README.markdown bin/testbot) +
+  s.files       = Dir.glob("lib/**/*") + Dir.glob("test/**/*") + %w(Gemfile .gemtest Rakefile testbot.gemspec CHANGELOG README.markdown bin/testbot) +
                   (File.exists?("DEV_VERSION") ? [ "DEV_VERSION" ] : [])
   s.add_dependency('sinatra', '=1.0.0') # To be able to use rack 1.0.1 which is compatible with rails 2.
   s.add_dependency('httparty', '>= 0.6.1')
@@ -27,5 +27,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency("cucumber")
   s.add_development_dependency("rvm")
   s.add_development_dependency("rake")
+  s.add_development_dependency("bundler")
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: testbot
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: 
   segments: 
   - 0
   - 5
-  - 2
-  version: 0.5.2
+  - 3
+  version: 0.5.3
 platform: ruby
 authors: 
 - "Joakim Kolsj\xC3\xB6"
@@ -212,6 +212,20 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id013
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id014 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id014
 description: Testbot is a test distribution tool that works with Rails, RSpec, Test::Unit and Cucumber.
 email: 
 - joakim.kolsjo@gmail.com
@@ -249,8 +263,25 @@ files:
 - lib/shared/testbot.rb
 - lib/tasks/testbot.rake
 - lib/testbot.rb
+- test/fixtures/local/config/testbot.yml
+- test/fixtures/local/log/test.log
+- test/fixtures/local/Rakefile
+- test/fixtures/local/script/spec
+- test/fixtures/local/spec/models/car_spec.rb
+- test/fixtures/local/spec/models/house_spec.rb
+- test/fixtures/local/spec/spec.opts
+- test/fixtures/local/tmp/restart.txt
+- test/requester/test_requester.rb
+- test/runner/test_job.rb
+- test/server/test_group.rb
+- test/server/test_server.rb
+- test/shared/adapters/helpers/test_ruby_env.rb
+- test/shared/adapters/test_adapter.rb
+- test/shared/test_testbot.rb
+- test/test_integration.rb
 - Gemfile
 - .gemtest
+- Rakefile
 - testbot.gemspec
 - CHANGELOG
 - README.markdown