testbot_instructure 0.7.8

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

@@ -0,0 +1,108 @@
+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
+
+  def setup
+    # Can't override a stub in flexmock?
+    def RubyEnv.rvm?; false; end
+  end
+
+  context "self.bundler?" do
+
+    should "return true if bundler is installed and there is a Gemfile" do
+      flexmock(Gem::Specification).should_receive(:find_by_name).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::Specification).should_receive(:find_by_name).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::Specification).should_receive(:find_by_name).with("bundler").once.and_return(false)
+      assert_equal false, RubyEnv.bundler?("path/to/project")
+    end
+
+  end
+
+  context "self.rvm_prefix" do
+
+    should "return rvm prefix if rvm is installed" do
+      def RubyEnv.rvm?; true; end
+      flexmock(File).should_receive(:exists?).with("path/to/project/.rvmrc").once.and_return(true)
+      flexmock(File).should_receive(:read).with("path/to/project/.rvmrc").once.and_return("rvm 1.8.7\n")
+      assert_equal "rvm 1.8.7 exec", RubyEnv.rvm_prefix("path/to/project")
+    end
+
+    should "return nil if rvm is not installed" do
+      assert_equal nil, RubyEnv.rvm_prefix("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 "not look for a script when none is provided" do
+      assert_equal 'ruby -S rspec', RubyEnv.ruby_command("path/to/project", :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_interpreter => "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_interpreter => "jruby")
+    end
+
+    should "work when there is no binary specified and bundler is present" do
+      flexmock(RubyEnv).should_receive(:bundler?).and_return(true)
+      flexmock(File).should_receive(:exists?).and_return(false)
+      assert_equal 'ruby -S bundle exec', RubyEnv.ruby_command("path/to/project")
+    end
+
+    should "work when there is no binary specified and bundler is not present" do
+      flexmock(RubyEnv).should_receive(:bundler?).and_return(false)
+      flexmock(File).should_receive(:exists?).and_return(false)
+      assert_equal 'ruby -S', RubyEnv.ruby_command("path/to/project")
+    end
+
+
+  end
+
+end

data/test/shared/adapters/rspec_adapter_test.rb

@@ -0,0 +1,109 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../lib/shared/adapters/rspec_adapter.rb'))
+require 'test/unit'
+require 'shoulda'
+
+class RspecAdapterTest < Test::Unit::TestCase
+
+  context "sum_results" do
+
+    should "be able to parse and sum results" do
+      results =<<STR
+srv-y5ei5:/tmp/testbot
+..................FF..................................................
+
+Finished in 4.962975 seconds
+
+69 examples, 2 failures
+
+
+testbot1:/tmp/testbot
+.............F...........*........................
+
+Finished in 9.987141 seconds
+
+50 examples, 1 failure, 1 pending
+
+testbot1:/tmp/testbot
+.............FF.......****........................
+
+Finished in 9.987141 seconds
+
+50 examples, 2 failures, 3 pending
+
+testbot1:/tmp/testbot
+.
+
+Finished in 9.987141 seconds
+
+1 example, 0 failures, 0 pending
+STR
+      assert_equal "170 examples, 5 failures, 4 pending", Color.strip(RspecAdapter.sum_results(results))
+    end
+
+    should "return 0 examples and failures for an empty resultset" do
+      assert_equal "0 examples, 0 failures", Color.strip(RspecAdapter.sum_results(""))
+    end
+
+    should "print in singular for examples" do
+      str =<<STR
+testbot1:/tmp/testbot
+.
+
+Finished in 9.987141 seconds
+
+1 example, 0 failures
+STR
+      assert_equal "1 example, 0 failures", Color.strip(RspecAdapter.sum_results(str))
+    end
+
+    should "print in singular for failures" do
+      str =<<STR
+testbot1:/tmp/testbot
+F
+
+Finished in 9.987141 seconds
+
+0 example, 1 failures
+STR
+      assert_equal "0 examples, 1 failure", Color.strip(RspecAdapter.sum_results(str))
+    end
+    
+    should "make the result green if there is no failed or pending examples" do
+      str =<<STR
+testbot1:/tmp/testbot
+.
+
+Finished in 9.987141 seconds
+
+1 example, 0 failures
+STR
+      assert_equal "\033[32m1 example, 0 failures\033[0m", RspecAdapter.sum_results(str)
+    end
+
+    should "make the result orange if there is pending examples" do
+      str =<<STR
+testbot1:/tmp/testbot
+*
+
+Finished in 9.987141 seconds
+
+1 example, 0 failures, 1 pending
+STR
+      assert_equal "\033[33m1 example, 0 failures, 1 pending\033[0m", RspecAdapter.sum_results(str)
+    end
+
+    should "make the results red if there is failed examples" do
+      str = <<STR
+testbot1:/tmp/testbot
+F
+
+Finished in 9.987141 seconds
+
+1 example, 1 failures
+STR
+      assert_equal "\033[31m1 example, 1 failure\033[0m", RspecAdapter.sum_results(str)
+    end
+
+  end
+
+end

data/test/shared/testbot_test.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/testbot.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path(File.dirname(__FILE__) + '/lib/shared/version')
+
+Gem::Specification.new do |s|
+  s.name        = "testbot_instructure"
+  s.version     = Testbot.version
+  s.authors     = ["Joakim Kolsjö"]
+  s.email       = ["joakim.kolsjo@gmail.com"]
+  s.homepage    = "http://github.com/joakimk/testbot"
+  s.summary     = %q{A test distribution tool forked for instructure.}
+  s.description = %q{Testbot is a test distribution tool that works with Rails, RSpec, RSpec2, Test::Unit and Cucumber.}
+  s.bindir      = "bin"
+  s.executables = [ "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')
+  s.add_dependency('httparty', '>= 0.6.1')
+  s.add_dependency('net-ssh', '>= 2.0.23')
+  s.add_dependency('json_pure', '>= 1.4.6')
+  s.add_dependency('daemons', '>= 1.0.10')
+  s.add_dependency('acts_as_rails3_generator')
+  s.add_dependency('posix-spawn', '>= 0.3.6')
+
+  s.add_development_dependency("shoulda")
+  s.add_development_dependency("rack-test")
+  s.add_development_dependency("flexmock")
+  s.add_development_dependency("rvm")
+  s.add_development_dependency("rake", "0.8.7")
+  s.add_development_dependency("bundler")
+  s.add_development_dependency("guard")
+  s.add_development_dependency("guard-test")
+end
+