tlb-rspec1 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+TAGS
+tmp
+tlb_store
+tlb-all*.jar

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "tlb"]
+	path = tlb
+	url = git://github.com/test-load-balancer/tlb.git

data/README.markdown

@@ -0,0 +1,30 @@
+## Using tlb_rb:
+
+tlb_rb uses [tlb](https://github.com/test-load-balancer/tlb "TLB") under the hood. It runs a sub-process(java process) which talks to the actual tlb-server(or equivallent) to balance and post run-feedback.
+Balancer process is actually an HTTP server which needs to listen to a certain TCP port so that tlb-ruby implementation can talk to it. 
+This is controlled by an environment variable named *'TLB_BALANCER_PORT'*, which can be set to any port number(integer between 1024 to 65535) that is guaranteed to remain un-bound while the build runs.
+
+In addition to this extra environment variable, the usual TLB environment variable setup is required(so the balancer knows things like what partitioning algorithm to use or what server to talk to). 
+Detailed documentation of TLB environment variable configuration is available at [https://github.com/test-load-balancer/tlb/wiki/Configuration-Variables](https://github.com/test-load-balancer/tlb/wiki/Configuration-Variables "Tlb config reference")
+
+As of now, rspec is the only test framework that tlb_rb supports. We plan to add support for other ruby-testing-frameworks soon.
+
+## Setting it up for your project
+
+Please refer the [sample_projects](http://github.com/test-load-balancer/sample_projects "Tlb setup examples") to see the details of how to set it up.
+
+Usually, something equivallent of this in one of your Rake files should suffice:
+
+    PATH_TO_TLB = File.join(RAILS_ROOT, 'vendor', 'plugins', 'tlb_rb', 'lib', 'tlb')
+    require PATH_TO_TLB
+    require File.join(PATH_TO_TLB, 'spec_task')
+  
+    Tlb::SpecTask.new(:balanced_specs) do |t|
+      t.spec_files = FileList['spec/**/*_spec.rb']
+      t.spec_opts << "--require #{PATH_TO_TLB},#{File.join(PATH_TO_TLB, 'spec_formatter')} --format 'Tlb::SpecFormatter:/dev/null' --format nested"
+    end
+  
+    desc "load balanced spec"
+    task :run_balanced => ['tlb:start', :balanced_specs]
+  
+Where run_balanced is the task you invoke at the top-level(invoked externally).

data/Rakefile

@@ -0,0 +1,15 @@
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+task :build_tlb do
+  Dir.glob("tlb-all*.jar").each { |jar| FileUtils.rm(jar) }
+  sh 'ant -f tlb/build.xml package'
+  Dir.glob('tlb/target/tlb-all*').each { |file| FileUtils.copy(file, ".") }
+end
+
+task :package do
+  `gem build tlb-rspec1.gemspec`
+end

data/gem_common.rb

@@ -0,0 +1,56 @@
+BASE_DIR = File.dirname(__FILE__)
+LIB_TLB = File.join(BASE_DIR, "lib", "tlb")
+TEST_DIR = File.join(BASE_DIR, "tests")
+TAG_VERSION = `git describe --abbrev=0`.gsub(/^v/, '').gsub(/-rspec-1$/, '')
+CODE_VERSION = `git describe --always`
+AUTHORS = ["Janmejay Singh", "Pavan KS"]
+EMAIL = "singh.janmejay@gmail.com;itspanzi@gmail.com"
+HOME_PAGE = "http://github.com/test-load-balancer/tlb_rb"
+SUMMARY = "#{$name}-#{CODE_VERSION}"
+DESC = <<END
+TLB ruby implementation base, which provides support for load balancing tests written in #{$framework}.
+TLB_rb test suite is not bundled, please check http://github.com/test-load-balancer/tlb_rb for tests.
+Detailed configuration documentation can be found at https://github.com/test-load-balancer/tlb/wiki.
+END
+POST_INSTALL_MESSAGE = <<END
+-------------------------------------------------------------------------
+Documentation: Detailed configuration documentation can be found at https://github.com/test-load-balancer/tlb/wiki.
+-----------------------------
+Example: https://github.com/test-load-balancer/sample_projects has examples projects and shell script to demonstrate a typical build(by starting a local tlb server, and executing two partitions locally). While partitions in these examples execute one after another, in an actual CI/pre-checkin build, they will actually run parallely on different machines.
+Its a good idea to play with the environment variables values being used in these shell-scripts to understand how they affect TLB's behaviour. You may want to check https://github.com/test-load-balancer/tlb/wiki/Configuration-Variables, which documents each variable and its effect.
+-----------------------------
+Issue tracker: Please report bugs/enhancements/feature-requests at http://code.google.com/p/tlb/issues/list. Github, Rubyforge or any other issue trackers are not monitored or updated.
+-------------------------------------------------------------------------
+END
+RUBYFORGE_PROJECT = "tlb-rb"
+RUBYGEMS_VERSION = "1.3.7"
+
+def files *exclude_dirs
+  files = `git ls-files`.split("\n")
+  files += Dir.glob(File.join(File.dirname(__FILE__), "*.jar")).map { |path| File.basename(path) }
+  exclude_dirs.inject(files) { |files, dir| files - `git ls-files #{dir}`.split("\n") }
+end
+
+
+def configure_tlb s
+  s.name        = $name
+  s.version     = TAG_VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = AUTHORS
+  s.email       = EMAIL
+  s.homepage    = HOME_PAGE
+  s.summary     = SUMMARY
+  s.description = DESC
+
+  s.rubyforge_project = RUBYFORGE_PROJECT
+  s.rubygems_version = RUBYGEMS_VERSION
+
+  s.post_install_message = POST_INSTALL_MESSAGE
+
+  s.extra_rdoc_files = [ "README.markdown" ]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+
+  s.add_runtime_dependency 'open4', '>= 1.0.1'
+  s.add_runtime_dependency 'rake'
+end

data/lib/tasks/tlb.rake

@@ -0,0 +1,12 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'tlb'))
+
+namespace :tlb do
+  task :start do
+    Tlb.start_server
+    at_exit do
+      $stderr.write "terminating tlb server\n"
+      Tlb.stop_server
+    end
+  end
+end
+

data/lib/tlb/spec_formatter.rb

@@ -0,0 +1,70 @@
+require 'spec/runner/formatter/silent_formatter'
+
+class Tlb::SpecFormatter < Spec::Runner::Formatter::SilentFormatter
+  class Suite < Struct.new(:file_name, :start_time, :end_time, :failed)
+    MILLS_PER_SEC = 1000
+
+    def initialize(file_name, start_time)
+      super(file_name, start_time, start_time, false)
+    end
+
+    def for_file? new_file
+      File.identical?(file_name, new_file)
+    end
+
+    def run_time
+      ((end_time - start_time)*MILLS_PER_SEC).to_i
+    end
+
+    def report_to_tlb
+      rel_file_name = Tlb.relative_file_path(file_name)
+      Tlb.suite_time(rel_file_name, run_time)
+      Tlb.suite_result(rel_file_name, failed)
+    end
+  end
+
+  def initialize(*args)
+    super(*args)
+    @suites = []
+  end
+
+  def example_group_started(example_proxy_group)
+    file_name = example_file_name(example_proxy_group)
+    unless (@suites.last && @suites.last.for_file?(file_name))
+      @suites << Tlb::SpecFormatter::Suite.new(file_name, Time.now)
+    end
+  end
+
+  def example_passed(example_proxy)
+    record_suite_data(example_proxy)
+  end
+
+  def example_failed(example_proxy, *ignore)
+    record_suite_data(example_proxy) do |suite|
+      suite.failed = true
+    end
+  end
+
+  def example_pending(example_proxy, *ignore)
+    record_suite_data(example_proxy)
+  end
+
+  def start_dump
+    @suites.each do |suite_time|
+      suite_time.report_to_tlb
+    end
+  end
+
+  private
+  def record_suite_data example_proxy
+    file_name = example_file_name(example_proxy)
+    if (suite = @suites.last) #stupid framework :: retarded fix (this is necessary since rspec creates example_proxies for every example it runs, as though its an independent spec-group)
+      suite.end_time = Time.now
+      block_given? && yield(suite)
+    end
+  end
+
+  def example_file_name example_proxy
+    example_proxy.location ? (@last_known_file = example_proxy.location.scan(/^(.+?):\d+(:.*)?$/).flatten.first) : @last_known_file
+  end
+end

data/lib/tlb/spec_task.rb

@@ -0,0 +1,22 @@
+require 'spec/rake/spectask'
+
+class Tlb::SpecTask < Spec::Rake::SpecTask
+  attr_accessor :tlb_out
+
+  def initialize *args
+    path_to_tlb = File.expand_path(File.join(File.dirname(__FILE__), '..', 'tlb'))
+    path_to_spec_formatter = File.expand_path(File.join(File.dirname(__FILE__), 'spec_formatter'))
+    self.tlb_out = '/dev/null'
+    super do |this|
+      yield this if block_given?
+      this.spec_opts.unshift "--require #{path_to_tlb},#{path_to_spec_formatter} --format 'Tlb::SpecFormatter:#{this.tlb_out}'"
+    end
+  end
+
+  alias_method :rspec_spec_file_list, :spec_file_list
+
+  def spec_file_list
+    balanced_and_reordered = Tlb.balance_and_order(rspec_spec_file_list.to_a)
+    FileList[*balanced_and_reordered]
+  end
+end

data/lib/tlb.rb

@@ -0,0 +1,135 @@
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "tlb"))
+require 'rubygems'
+require 'open4'
+require 'net/http'
+
+module Tlb
+  TLB_OUT_FILE = 'TLB_OUT_FILE'
+  TLB_ERR_FILE = 'TLB_ERR_FILE'
+  TLB_APP = 'TLB_APP'
+
+  module Balancer
+    TLB_BALANCER_PORT = 'TLB_BALANCER_PORT'
+    BALANCE_PATH = '/balance'
+    SUITE_TIME_REPORTING_PATH = '/suite_time'
+    SUITE_RESULT_REPORTING_PATH = '/suite_result'
+
+    def self.host
+      'localhost'
+    end
+
+    def self.port
+      ENV[TLB_BALANCER_PORT]
+    end
+
+    def self.send path, data
+      Net::HTTP.start(host, port) do |h|
+        res = h.post(path, data)
+        res.value
+        res.body
+      end
+    end
+
+    def self.get path
+      Net::HTTP.get_response(host, path, port).body
+    end
+
+    def self.running?
+      get("/control/status") == "RUNNING"
+    rescue
+      false
+    end
+
+    def self.wait_for_start
+      loop do
+        begin
+          TCPSocket.new(host, port)
+          break if running?
+        rescue
+          #ignore
+        end
+      end
+    end
+  end
+
+  def self.relative_file_path file_name
+    abs_file_name = File.expand_path(file_name)
+    rel_file_name = abs_file_name.sub(/^#{Dir.pwd}/, '.')
+  end
+
+  def self.balance_and_order file_set
+    ensure_server_running
+    Balancer.send(Balancer::BALANCE_PATH,
+                  file_set.map do |file_path|
+                    Tlb.relative_file_path(file_path)
+                  end.join("\n")).split("\n")
+  end
+
+  def self.suite_result suite_name, result
+    ensure_server_running
+    Balancer.send(Balancer::SUITE_RESULT_REPORTING_PATH, "#{suite_name}: #{result}")
+  end
+
+  def self.suite_time suite_name, mills
+    ensure_server_running
+    Balancer.send(Balancer::SUITE_TIME_REPORTING_PATH, "#{suite_name}: #{mills}")
+  end
+
+  def self.fail_as_balancer_is_not_running
+    raise "Balancer server must be started before tests are run."
+  end
+
+  def self.ensure_server_running
+    server_running? || fail_as_balancer_is_not_running
+  end
+
+  def self.server_running?
+    Balancer.running?
+  end
+
+  def self.root_dir
+    File.expand_path(File.join(File.dirname(__FILE__), ".."))
+  end
+
+  def self.tlb_jar
+    File.expand_path(Dir.glob(File.join(root_dir, "tlb-all*")).first)
+  end
+
+  def self.server_command
+    "java -jar #{tlb_jar}"
+  end
+
+  def self.write_to_file file_var, clob
+    File.open(ENV[file_var], 'a') do |h|
+      h.write(clob)
+    end
+  end
+
+  def self.start_server
+    ENV[TLB_APP] = 'com.github.tlb.balancer.BalancerInitializer'
+    @pid, input, out, err = Open4.popen4(server_command)
+    @out_pumper = stream_pumper_for(out, TLB_OUT_FILE)
+    @err_pumper = stream_pumper_for(err, TLB_ERR_FILE)
+    Balancer.wait_for_start
+  end
+
+  def self.stream_pumper_for stream, dump_file
+    Thread.new do
+      loop do
+        stream.eof? || write_to_file(dump_file, stream.read)
+        Thread.current[:stop_pumping] && break
+        sleep 1
+      end
+    end
+  end
+
+  def self.stop_server
+    Process.kill(Signal.list["TERM"], @pid)
+    @pid = nil
+    @out_pumper[:stop_pumping] = true
+    @err_pumper[:stop_pumping] = true
+    @out_pumper.join
+    @err_pumper.join
+    Process.wait
+  end
+end

data/spec/fixtures/foo.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+while [[ true ]] ;
+do
+    echo "hello out"
+    echo "hello err" 1>&2
+    sleep 1
+done

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'mocha'
+require 'spec'
+require 'rake'
+$LOAD_PATH.unshift(File.dirname(__FILE__), "..", "lib")
+require 'tlb'
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end
+
+def tmp_file file_name
+  path = File.join(Dir.tmpdir, file_name)
+  file = File.new(path, 'w')
+  File.truncate path, 0
+  file.close
+  file
+end
+

data/spec/tlb/spec_formatter_spec.rb

@@ -0,0 +1,140 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+require 'spec_formatter'
+require 'spec/example/example_proxy'
+require 'spec/example/example_group_proxy'
+
+describe Tlb::SpecFormatter do
+  before :all do
+    FileUtils.mkdir_p(@dir = Dir.pwd + "/tmp/foo/../bar/..")
+  end
+
+  before do
+    @group_1, @file_1 = stubbed_group("baz/group1")
+    @group_2, @file_2 = stubbed_group("group2")
+    @group_3, @file_3 = stubbed_group("group3")
+    @group_proxy_1 = Spec::Example::ExampleGroupProxy.new(@group_1)
+    @group_proxy_2 = Spec::Example::ExampleGroupProxy.new(@group_2)
+    @group_proxy_3 = Spec::Example::ExampleGroupProxy.new(@group_3)
+    @formatter = Tlb::SpecFormatter.new(nil, nil)
+  end
+
+  def stubbed_group group_name
+    grp = stub(group_name)
+    grp.expects(:description).returns("#{group_name} desc")
+    grp.expects(:nested_descriptions).returns("#{group_name} nested desc")
+    grp.expects(:example_proxies).returns("#{group_name} example proxies")
+    grp.expects(:options).returns({:name => group_name})
+
+    file_name = "#{@dir}/#{group_name}.rb"
+    FileUtils.mkdir_p(File.dirname(file_name))
+    File.open(file_name, 'w') do |h|
+      h.write("something")
+    end
+    rel_file_name = File.expand_path(file_name).sub(Dir.pwd, '.')
+    grp.expects(:location).times(2).returns(file_name + ":4")
+
+    [grp, rel_file_name]
+  end
+
+  it "should be silent formatter" do
+    @formatter.should be_a(Spec::Runner::Formatter::SilentFormatter)
+  end
+
+  it "should use last finished example's time" do
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 5, 10))
+    @formatter.example_group_started(@group_proxy_1)
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 5, 20))
+    @formatter.example_passed(Spec::Example::ExampleProxy.new("group1 spec 1", {}, "#{@dir}/baz/group1.rb:12"))
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 5, 22))
+    @formatter.example_failed(Spec::Example::ExampleProxy.new("group1 spec 2", {}, "#{@dir}/baz/group1.rb:40"), 1, "ignore")
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 5, 29))
+    @formatter.example_pending(Spec::Example::ExampleProxy.new("group1 spec 3", {}, "#{@dir}/baz/group1.rb:55"), "some reason")
+
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 6, 00))
+    @formatter.example_group_started(@group_proxy_2)
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 6, 12))
+    @formatter.example_pending(Spec::Example::ExampleProxy.new("group2 spec 1", {}, "#{@dir}/group2.rb:5"), "some reason")
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 6, 25))
+    @formatter.example_passed(Spec::Example::ExampleProxy.new("group2 spec 2", {}, "#{@dir}/group2.rb:38"))
+
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 7, 15))
+    @formatter.example_group_started(@group_proxy_3)
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 8, 12))
+    @formatter.example_pending(Spec::Example::ExampleProxy.new("group3 spec 1", {}, "#{@dir}/group3.rb:45"), "some reason")
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 8, 55))
+    @formatter.example_failed(Spec::Example::ExampleProxy.new("group3 spec 2", {}, "#{@dir}/group3.rb:80"), 3, "ignore")
+
+    Tlb.stubs(:suite_result)
+
+    Tlb.expects(:suite_time).with(@file_1, 19000)
+    Tlb.expects(:suite_time).with(@file_2, 25000)
+    Tlb.expects(:suite_time).with(@file_3, 100000)
+
+    @formatter.start_dump
+  end
+
+  it "should report suite result to tlb" do
+    @formatter.example_group_started(@group_proxy_1)
+    @formatter.example_passed(Spec::Example::ExampleProxy.new("group1 spec 1", {}, "#{@dir}/baz/group1.rb:12"))
+    @formatter.example_failed(Spec::Example::ExampleProxy.new("group1 spec 2", {}, "#{@dir}/baz/group1.rb:40"), 1, "ignore")
+    @formatter.example_pending(Spec::Example::ExampleProxy.new("group1 spec 3", {}, "#{@dir}/baz/group1.rb:55"), "some reason")
+
+    @formatter.example_group_started(@group_proxy_2)
+    @formatter.example_pending(Spec::Example::ExampleProxy.new("group2 spec 1", {}, "#{@dir}/group2.rb:5"), "some reason")
+    @formatter.example_passed(Spec::Example::ExampleProxy.new("group2 spec 2", {}, "#{@dir}/group2.rb:38"))
+
+    @formatter.example_group_started(@group_proxy_3)
+    @formatter.example_pending(Spec::Example::ExampleProxy.new("group3 spec 1", {}, "#{@dir}/group3.rb:45"), "some reason")
+    @formatter.example_failed(Spec::Example::ExampleProxy.new("group3 spec 2", {}, "#{@dir}/group3.rb:80"), 3, "ignore")
+    @formatter.example_passed(Spec::Example::ExampleProxy.new("group3 spec 3", {}, "#{@dir}/group3.rb:85"))
+    @formatter.example_passed(Spec::Example::ExampleProxy.new("group3 spec 4", {}, "#{@dir}/group3.rb:103"))
+
+    Tlb.stubs(:suite_time)
+
+    Tlb.expects(:suite_result).with(@file_1, true)
+    Tlb.expects(:suite_result).with(@file_2, false)
+    Tlb.expects(:suite_result).with(@file_3, true)
+
+    @formatter.start_dump
+  end
+
+  it "should parse example_file_name" do
+    @formatter.send(:example_file_name, Spec::Example::ExampleProxy.new("some method call inside spec", {}, "./spec/baz_quux.rb:9")).should == "./spec/baz_quux.rb"
+    @formatter.send(:example_file_name, Spec::Example::ExampleProxy.new("some method call inside spec", {}, "./spec/foo_bar_baz.rb:9:in `should_quux'")).should == "./spec/foo_bar_baz.rb"
+  end
+
+  it "should report suite result for last heard file name when it received example_proxy having no location" do
+    @formatter.example_group_started(@group_proxy_1)
+    @formatter.example_failed(Spec::Example::ExampleProxy.new("before(:all)"))
+    Tlb.stubs(:suite_time)
+
+    Tlb.expects(:suite_result).with(@file_1, true)
+
+    @formatter.start_dump
+  end
+
+  it "should share the same suite when example_group starts twice(this happens in nested describe blocks)" do
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 5, 10))
+    @formatter.example_group_started(@group_proxy_1)
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 5, 20))
+    @formatter.example_passed(Spec::Example::ExampleProxy.new("group1 spec 1", {}, "#{@dir}/baz/group1.rb:12"))
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 5, 22))
+    @formatter.example_failed(Spec::Example::ExampleProxy.new("group1 spec 2", {}, "#{@dir}/baz/group1.rb:40"), 1, "ignore")
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 5, 29))
+    @formatter.example_pending(Spec::Example::ExampleProxy.new("group1 spec 3", {}, "#{@dir}/baz/group1.rb:55"), "some reason")
+
+    @formatter.example_group_started(@group_proxy_1)
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 6, 12))
+    @formatter.example_failed(Spec::Example::ExampleProxy.new("group1 spec 4(nested)", {}, "#{@dir}/baz/group1.rb:100"), 1, "foo_bar")
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 6, 25))
+    @formatter.example_pending(Spec::Example::ExampleProxy.new("group1 spec 4(nested)", {}, "#{@dir}/baz/group1.rb:130"), "some pending")
+    Time.expects(:now).returns(Time.local( 2010, "jul", 16, 12, 7, 15))
+    @formatter.example_passed(Spec::Example::ExampleProxy.new("group1 spec 4(nested)", {}, "#{@dir}/baz/group1.rb:145"))
+
+    Tlb.stubs(:suite_result)
+
+    Tlb.expects(:suite_time).with(@file_1, 125000)
+    @formatter.start_dump
+  end
+
+end

data/spec/tlb/spec_task_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+require 'spec_task'
+
+describe Tlb::SpecTask do
+  before(:all) do
+    @path_to_tlb = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'tlb'))
+    @path_to_spec_formatter = File.expand_path(File.join(@path_to_tlb, 'spec_formatter'))
+  end
+
+  it "should return balanced and ordered subset" do
+    @task = Tlb::SpecTask.new
+    Tlb.stubs(:start_unless_running)
+    @task.expects(:rspec_spec_file_list).returns(FileList['foo.rb', 'bar.rb', 'baz.rb', 'quux.rb'])
+    Tlb.stubs(:balance_and_order).with(['foo.rb', 'bar.rb', 'baz.rb', 'quux.rb']).returns(['quux.rb', 'foo.rb'])
+    balanced_list = @task.spec_file_list
+    balanced_list.should be_a(Rake::FileList)
+    balanced_list.to_a.should == ['quux.rb', 'foo.rb']
+  end
+
+  it "should hookup formatter so feedback is posted" do
+    @task = Tlb::SpecTask.new
+    @task.spec_opts.should == ["--require #{@path_to_tlb},#{@path_to_spec_formatter} --format 'Tlb::SpecFormatter:/dev/null'"]
+  end
+
+  it "should honor user specified attributes" do
+    @task = Tlb::SpecTask.new(:foo) do |t|
+      t.spec_opts << "--require foo_bar"
+      t.spec_opts << "--require baz_quux"
+    end
+    @task.spec_opts.should == ["--require #{@path_to_tlb},#{@path_to_spec_formatter} --format 'Tlb::SpecFormatter:/dev/null'", "--require foo_bar", "--require baz_quux"]
+    @task.name.should == :foo
+  end
+
+  it "should use specified output file for tlb's spec_formatter" do
+    @task = Tlb::SpecTask.new(:foo) do |t|
+      t.tlb_out = "/tmp/tlb_spec_formatter_out"
+    end
+    @task.spec_opts.should == ["--require #{@path_to_tlb},#{@path_to_spec_formatter} --format 'Tlb::SpecFormatter:/tmp/tlb_spec_formatter_out'"]
+  end
+end

data/spec/tlb_http_communication_spec.rb

@@ -0,0 +1,146 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'open4'
+require 'parsedate'
+require 'tmpdir'
+require 'webrick'
+
+describe Tlb do
+  URL = "http://localhost:7019"
+  JOB_NAME = "foo"
+  TLB_BALANCER_PORT = '9173'
+  before :all do
+    ENV['TLB_APP'] = 'com.github.tlb.server.TlbServerInitializer'
+    @pid, i, o, e = Open4.popen4(Tlb.server_command)
+  end
+
+  after :all do
+    Process.kill(Signal.list['KILL'], @pid)
+  end
+
+  it "should wait for balancer server to come up before returning from start_server" do
+    Tlb::Balancer.expects(:wait_for_start)
+    Open4.stubs(:popen4)
+    Tlb.start_server
+  end
+
+  describe "using server" do
+    before do
+      ENV[Tlb::TLB_OUT_FILE] = (@out_file = tmp_file('tlb_out_file').path)
+      ENV[Tlb::TLB_ERR_FILE] = (@err_file = tmp_file('tlb_err_file').path)
+      Tlb.server_running?.should be_false #precondition (the server must be started if not running)
+
+      ENV['TLB_BALANCER_PORT'] = TLB_BALANCER_PORT
+      ENV['TLB_URL'] = URL
+      ENV['TALK_TO_SERVICE'] = "com.github.tlb.service.TalkToTlbServer"
+      ENV['TLB_JOB_NAME'] = JOB_NAME
+      ENV['TOTAL_PARTITIONS'] = '2'
+      ENV['JOB_VERSION'] = '123'
+      ENV['TLB_CRITERIA'] = 'com.github.tlb.splitter.CountBasedTestSplitterCriteria'
+    end
+
+    after do
+      Tlb.server_running?.should be_true #api calls need not worry about killing it
+      Tlb.stop_server
+    end
+
+    it "should balance for first partition" do
+      ENV['PARTITION_NUMBER'] = '1'
+      Tlb.start_server
+      Tlb.balance_and_order(["foo/bar.rb", "foo/baz.rb", "bar/foo.rb", "bar/quux.rb"]).should == ["./foo/bar.rb", "./foo/baz.rb"]
+    end
+
+    it "should balance for second partition" do
+      ENV['PARTITION_NUMBER'] = '2'
+      Tlb.start_server
+      Tlb.balance_and_order(["foo/bar.rb", "foo/baz.rb", "bar/foo.rb", "bar/quux.rb"]).should == ["./bar/foo.rb", "./bar/quux.rb"]
+    end
+
+    it "should balance with file path names relative to working dir" do
+      ENV['PARTITION_NUMBER'] = '1'
+      Tlb.start_server
+      Tlb.balance_and_order(["foo/hi/../baz/quux/../hello/../../bar.rb", "foo/bar/../baz.rb", "bar/baz/quux/../../foo.rb", "bar/quux.rb"]).should == ["./foo/bar.rb", "./foo/baz.rb"]
+    end
+
+    describe "thats already running" do
+      before do
+        Tlb.start_server
+      end
+
+      it "should publish suite result" do
+        Tlb.suite_result("foo/bar.rb", true)
+        Tlb.suite_result("foo/baz.rb", false)
+        Tlb.suite_result("foo/quux.rb", true)
+        get_from_tlb_server("suite_result").should include("foo/bar.rb: true", "foo/baz.rb: false", "foo/quux.rb: true")
+      end
+
+      it "should publish suite time" do
+        Tlb.suite_time("foo/bar.rb", 102)
+        Tlb.suite_time("foo/baz.rb", 3599)
+        Tlb.suite_time("foo/quux.rb", 2010)
+        get_from_tlb_server("suite_time").should include("foo/bar.rb: 102", "foo/baz.rb: 3599", "foo/quux.rb: 2010")
+      end
+
+      def get_from_tlb_server path
+        body = Net::HTTP.get(URI.parse("#{URL}/#{JOB_NAME}/#{path}"))
+        body.split("\n")
+      end
+
+      it "should use send method to balance" do
+        Tlb::Balancer.expects(:send).with(Tlb::Balancer::BALANCE_PATH, "./foo/bar.rb\n./foo/baz.rb").returns("foo\nbar")
+        Tlb.balance_and_order(["foo/bar.rb", "foo/baz.rb"]).should == ["foo", "bar"]
+      end
+
+      it "should use send method to post results" do
+        Tlb::Balancer.expects(:send).with(Tlb::Balancer::SUITE_RESULT_REPORTING_PATH, "foo/bar.rb: false")
+        Tlb.suite_result("foo/bar.rb", false)
+      end
+
+      it "should use send method to post time" do
+        Tlb::Balancer.expects(:send).with(Tlb::Balancer::SUITE_TIME_REPORTING_PATH, "foo/bar.rb: 42")
+        Tlb.suite_time("foo/bar.rb", 42)
+      end
+
+      it "should raise exception when call to tlb fails" do
+        lambda do
+          Tlb::Balancer.send("/foo", "bar")
+        end.should raise_error(Net::HTTPServerException, '404 "The server has not found anything matching the request URI"')
+      end
+    end
+  end
+
+  describe :wait_for_server_to_start do
+    class CtrlStatus < WEBrick::HTTPServlet::AbstractServlet
+      def do_GET(request, response)
+        response.status = 200
+        response['Content-Type'] = 'text/plain'
+        response.body = 'RUNNING'
+      end
+    end
+    before do
+      @server = nil
+      ENV['TLB_BALANCER_PORT'] = TLB_BALANCER_PORT
+    end
+
+    after do
+      @server.shutdown
+    end
+
+    it "should wait until socket has a listener" do
+      @wait_completed = false
+      before_start = Time.now
+      wait_thread = Thread.new do
+        sleep 3
+        @wait_completed = true
+        @server = WEBrick::HTTPServer.new(:Port => TLB_BALANCER_PORT,
+                                          :Logger => WEBrick::BasicLog.new(tmp_file('tlb_webrick_log').path),
+                                          :AccessLog => WEBrick::BasicLog.new(tmp_file('tlb_webrick_access_log').path))
+        @server.mount '/control/status', CtrlStatus
+        @server.start
+      end
+      @wait_completed.should be_false
+      Tlb::Balancer.wait_for_start
+      @wait_completed.should be_true
+      Time.now.should > (before_start + 3)
+    end
+  end
+end

data/spec/tlb_process_control_spec.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'open4'
+require 'parsedate'
+require 'tmpdir'
+
+describe Tlb do
+  before do
+    ENV[Tlb::TLB_OUT_FILE] = (@out_file = tmp_file('tlb_out_file').path)
+    ENV[Tlb::TLB_ERR_FILE] = (@err_file = tmp_file('tlb_err_file').path)
+    Tlb::Balancer.stubs(:wait_for_start)
+  end
+
+  MOCK_PROCESS_ID = 33040
+  SIG_TERM = 15
+
+  it "should terminate process when stop called" do
+    Tlb.instance_variable_set('@pid', MOCK_PROCESS_ID)
+    Tlb.instance_variable_set('@out_pumper', Thread.new { })
+    Tlb.instance_variable_set('@err_pumper', Thread.new { })
+
+    Process.expects(:kill).with(SIG_TERM, MOCK_PROCESS_ID)
+    Process.expects(:wait).with()
+
+    Tlb.stop_server
+  end
+
+  def times_of_output content, stream_name
+    content.split("\n").map { |line| line.gsub(stream_name, '') }.map do |line|
+      year, month, day_of_month, hour, minute, second, timezone, day_of_week = ParseDate.parsedate(line)
+      Time.local(year, month, day_of_month, hour, minute, second)
+    end
+  end
+
+  it "should generate the right command to run tlb balancer server" do
+    tlb_jar = File.expand_path(Dir.glob(File.join(File.join(File.dirname(__FILE__), ".."), "tlb-all*")).first)
+    Tlb.server_command.should == "java -jar #{tlb_jar}"
+  end
+
+  describe :integration_test do
+    it "should pump both error and out to the file" do
+      Tlb.stubs(:wait_for_start)
+      Tlb.expects(:server_command).returns(File.join(File.dirname(__FILE__), "fixtures", "foo.sh"))
+      Tlb.start_server
+      sleep 2
+      Tlb.stop_server
+      File.read(@out_file).should include("hello out\n")
+      File.read(@err_file).should include("hello err\n")
+    end
+  end
+
+  it "should fail of server not running" do
+    Tlb.expects(:server_running?).returns(false)
+    lambda { Tlb.ensure_server_running }.should raise_error('Balancer server must be started before tests are run.')
+  end
+
+  it "should not start server if running" do
+    Tlb.expects(:server_running?).returns(true)
+    Tlb.expects(:start_server).never
+    Tlb.ensure_server_running
+  end
+
+  describe "env var" do
+    before do
+      module Open4
+        class << self
+          alias_method :old_popen4, :popen4
+        end
+
+        def self.popen4 command
+          ENV['TLB_APP'].should == "com.github.tlb.balancer.BalancerInitializer"
+        end
+      end
+    end
+
+    after do
+      module Open4
+        class << self
+          alias_method :popen4, :old_popen4
+        end
+      end
+    end
+
+    it "should set TLB_APP to point to balancer before starting the server" do
+      ENV['TLB_APP'] = "foo"
+      Tlb.stubs(:server_command).returns("foo bar")
+      Tlb.start_server
+    end
+  end
+end

data/tlb-rspec1.gemspec

@@ -0,0 +1,11 @@
+$name="tlb-rspec1"
+$framework='rspec-1.x'
+require File.join(File.dirname(__FILE__), 'gem_common')
+
+Gem::Specification.new do |s|
+  configure_tlb(s)
+
+  s.files            = files('tests', File.join('lib', 'tlb', 'test_unit'))
+
+  s.add_development_dependency 'rspec', '>= 1.3.0'
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: tlb-rspec1
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Janmejay Singh
+- Pavan KS
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-22 00:00:00 +05:30
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: open4
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id003
+description: |
+  TLB ruby implementation base, which provides support for load balancing tests written in rspec-1.x.
+  TLB_rb test suite is not bundled, please check http://github.com/test-load-balancer/tlb_rb for tests.
+  Detailed configuration documentation can be found at https://github.com/test-load-balancer/tlb/wiki.
+
+email: singh.janmejay@gmail.com;itspanzi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- .gitmodules
+- README.markdown
+- Rakefile
+- gem_common.rb
+- lib/tasks/tlb.rake
+- lib/tlb.rb
+- lib/tlb/spec_formatter.rb
+- lib/tlb/spec_task.rb
+- spec/fixtures/foo.sh
+- spec/spec_helper.rb
+- spec/tlb/spec_formatter_spec.rb
+- spec/tlb/spec_task_spec.rb
+- spec/tlb_http_communication_spec.rb
+- spec/tlb_process_control_spec.rb
+- tlb-rspec1.gemspec
+- tlb-all-gv0.2-9-g1f1a4aa.jar
+has_rdoc: true
+homepage: http://github.com/test-load-balancer/tlb_rb
+licenses: []
+
+post_install_message: |
+  -------------------------------------------------------------------------
+  Documentation: Detailed configuration documentation can be found at https://github.com/test-load-balancer/tlb/wiki.
+  -----------------------------
+  Example: https://github.com/test-load-balancer/sample_projects has examples projects and shell script to demonstrate a typical build(by starting a local tlb server, and executing two partitions locally). While partitions in these examples execute one after another, in an actual CI/pre-checkin build, they will actually run parallely on different machines.
+  Its a good idea to play with the environment variables values being used in these shell-scripts to understand how they affect TLB's behaviour. You may want to check https://github.com/test-load-balancer/tlb/wiki/Configuration-Variables, which documents each variable and its effect.
+  -----------------------------
+  Issue tracker: Please report bugs/enhancements/feature-requests at http://code.google.com/p/tlb/issues/list. Github, Rubyforge or any other issue trackers are not monitored or updated.
+  -------------------------------------------------------------------------
+
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: tlb-rb
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: tlb-rspec1-0.1.0-rspec-1
+test_files: []
+