integrity-bob 0.2.0 → 0.3.0

data/Rakefile

@@ -26,6 +26,7 @@ SCMs = %w[git svn]
 desc "Run unit tests"
 task :test => SCMs.map { |scm| "test:#{scm}" } do
   ruby "test/bob_test.rb"
+  ruby "test/test_test.rb"
   ruby "test/engine/threaded_test.rb"
 end
 

data/bob.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name    = "bob"
-  s.version = "0.2.0"
+  s.version = "0.3.0"
   s.date    = "2009-07-02"
 
   s.description = "Bob the Builder will build your code. Simple."
@@ -19,7 +19,6 @@ Gem::Specification.new do |s|
 
   if s.respond_to?(:add_development_dependency)
     s.add_development_dependency "sr-mg"
-    s.add_development_dependency "sr-bob-test"
     s.add_development_dependency "contest"
     s.add_development_dependency "redgreen"
     s.add_development_dependency "ruby-debug"
@@ -41,11 +40,17 @@ lib/bob/scm.rb
 lib/bob/scm/abstract.rb
 lib/bob/scm/git.rb
 lib/bob/scm/svn.rb
+lib/bob/test.rb
+lib/bob/test/buildable_stub.rb
+lib/bob/test/scm/abstract.rb
+lib/bob/test/scm/git.rb
+lib/bob/test/scm/svn.rb
 lib/core_ext/object.rb
 test/bob_test.rb
 test/engine/threaded_test.rb
 test/helper.rb
 test/scm/git_test.rb
 test/scm/svn_test.rb
+test/test_test.rb
 ]
 end

data/lib/bob/buildable.rb

@@ -1,12 +1,9 @@
 module Bob
   # Mixin to add to your classes.
   module Buildable
-    # Builds the list of commits you pass. You must provide an
-    # enumerable with commit identifiers appropriate to the
-    # repository the code is in (SHAs if git, rev numbers if svn,
-    # etc), or a single string with a commit id.
-    def build(commits)
-      Bob.build(self, commits)
+    # Build itself.
+    def build
+      Bob.build(self)
     end
 
     # What kind of repository this buildable represents. Must
@@ -31,6 +28,17 @@ module Bob
       raise NotImplementedError
     end
 
+    # Indentifier of the commit to build.
+    #
+    # The special identifier <tt>:head</tt> will be resolved to the head
+    # commit of the current branch (for example, "HEAD" under git or the
+    # latest revision under svn)
+    #
+    # <b>You must implement this in the classes where you mixin this module</b>
+    def commit
+      raise NotImplementedError
+    end
+
     # Script that will be run in the buildable's checked out code,
     # if it returns a status code of 0 it will be considered a
     # successfull build. Else it will be considered a failed build.

data/lib/bob/builder.rb

@@ -1,18 +1,13 @@
 module Bob
-  # A Builder will take care of building a buildable (wow, you didn't see that coming,
-  # right?).
+  # A Builder will take care of building a buildable (wow, you didn't see
+  # that coming, right?).
   class Builder
     attr_reader :buildable
 
-    # Instantiate the Builder, passing an object that understands the <tt>Buildable</tt>
-    # interface, and a <tt>commit_id</tt>.
-    #
-    # You can pass <tt>:head</tt> as the commit id, in which case it will resolve to the
-    # head commit of the current branch (for example, "HEAD" under git, or the latest
-    # revision under svn)
-    def initialize(buildable, commit_id)
+    # Instantiate the Builder, passing an object that understands
+    # the <tt>Buildable</tt> interface.
+    def initialize(buildable)
       @buildable = buildable
-      @commit_id = commit_id
     end
 
     # This is where the magic happens:
@@ -22,21 +17,21 @@ module Bob
     # 3. Run the build script on it in the background.
     # 4. Reports the build back to the buildable.
     def build
-      Bob.logger.info "Building #{commit_id} of the #{buildable.scm} repo at #{buildable.uri}"
+      Bob.logger.info "Building #{buildable.commit} of the #{buildable.scm} repo at #{buildable.uri}"
 
       in_background do
-        scm.with_commit(commit_id) {
-          buildable.start_building(commit_id, scm.info(commit_id))
+        scm.with_commit(commit) {
+          buildable.start_building(commit, scm.info(commit))
           build_status, build_output = run_build_script
-          buildable.finish_building(commit_id, build_status, build_output)
+          buildable.finish_building(commit, build_status, build_output)
         }
       end
     end
 
     private
 
-    def commit_id
-      @commit_id == :head ? scm.head : @commit_id
+    def commit
+      @commit ||= buildable.commit == :head ? scm.head : buildable.commit
     end
 
     def run_build_script
@@ -50,7 +45,7 @@ module Bob
     end
 
     def build_script
-      "(cd #{scm.working_dir} && #{buildable.build_script} 2>&1)"
+      "(cd #{scm.directory_for(commit)} && #{buildable.build_script} 2>&1)"
     end
 
     def scm

data/lib/bob/engine/threaded.rb

@@ -6,8 +6,9 @@ module Bob
     # in-memory queue, and processes them as soon as possible.
     class Threaded
       # The optional pool size controls how many threads will be created.
-      def initialize(pool_size = 2)
-        @pool = ThreadPool.new(pool_size)
+      def initialize(pool_size = 2, logger = Bob.logger)
+        @pool   = ThreadPool.new(pool_size)
+        @logger = logger
       end
 
       # Adds a job to the queue.
@@ -90,11 +91,12 @@ module Bob
         end
 
         # Default pool size is 2 threads.
-        def initialize(size = nil)
+        def initialize(size = nil, logger = Bob.logger)
           size ||= 2
           @jobs    = Queue.new
           @njobs   = Incrementor.new
           @workers = Array.new(size) { spawn }
+          @logger  = logger
         end
 
         # Adds a job to the queue, the job can be any number of objects
@@ -127,7 +129,12 @@ module Bob
             c[:run] = true
 
             while c[:run]
-              @jobs.pop.call
+              job = @jobs.pop
+              begin
+                job.call
+              rescue Exception => e
+                @logger.error("Exception occured during build of #{job.uri} commit #{job.commit}: #{e.message}")
+              end
               @njobs.dec
             end
           end

data/lib/bob/scm/abstract.rb

@@ -8,29 +8,27 @@ module Bob
         @branch = branch
       end
 
-      # Checkout the code into <tt>working_dir</tt> at the specified revision
-      # and call the passed block
-      def with_commit(commit_id)
-        update_code
-        checkout(commit_id)
+      # Checkout the code at the specified <tt>commit</tt> and call the
+      # passed block.
+      def with_commit(commit)
+        update_code(commit)
+        checkout(commit)
         yield
       end
 
-      # Directory where the code will be checked out. Make sure the user
-      # running Bob is allowed to write to this directory (or you'll get a
-      # <tt>Errno::EACCESS</tt>)
-      def working_dir
-        @working_dir ||= "#{Bob.directory}/#{path}".tap { |dir|
-          FileUtils.mkdir_p(dir)
-        }
+      # Directory where the code will be checked out for the given
+      # <tt>commit</tt>.
+      def directory_for(commit)
+        File.join(Bob.directory, "#{path}-#{commit}")
       end
 
-      # Get some information about the specified commit. Returns a hash with:
+      # Get some information about the specified <tt>commit</tt>.
+      # Returns a hash with:
       #
       # [<tt>:author</tt>]       Commit author's name and email
       # [<tt>:message</tt>]      Commit message
       # [<tt>:committed_at</tt>] Commit date (as a <tt>Time</tt> object)
-      def info(commit_id)
+      def info(commit)
         raise NotImplementedError
       end
 
@@ -42,8 +40,8 @@ module Bob
 
       protected
 
-      def run(command, cd=true)
-        command = "(#{cd ? "cd #{working_dir} && " : ""}#{command} &>/dev/null)"
+      def run(command, directory=nil)
+        command = "(#{directory ? "cd #{directory} && " : ""}#{command} &>/dev/null)"
         Bob.logger.debug(command)
         system(command) || raise(Error, "Couldn't run SCM command `#{command}`")
       end

data/lib/bob/scm/git.rb

@@ -1,9 +1,17 @@
 module Bob
   module SCM
     class Git < Abstract
-      def info(commit_id)
-        format  = %Q(---%n:author: %an <%ae>%n:message: >-%n  %s%n:committed_at: %ci%n)
-        YAML.load(`cd #{working_dir} && git show -s --pretty=format:"#{format}" #{commit_id}`).tap { |info|
+      def initialize(uri, branch)
+        super
+
+        unless File.directory?(File.join(Bob.directory, "cache"))
+          FileUtils.mkdir(File.join(Bob.directory, "cache"))
+        end
+      end
+
+      def info(commit)
+        format = %Q(---%n:author: %an <%ae>%n:message: >-%n  %s%n:committed_at: %ci%n)
+        YAML.load(`cd #{directory_for(commit)} && git show -s --pretty=format:"#{format}" #{commit}`).tap { |info|
           info[:committed_at] = Time.parse(info[:committed_at])
         }
       end
@@ -14,31 +22,30 @@ module Bob
 
       private
 
-      def update_code
-        cloned? ? fetch : clone
-      end
+      def update_code(commit)
+        unless File.directory?("#{cache_directory}/.git")
+          run "git clone -n #{uri} #{cache_directory}"
+        end
 
-      def cloned?
-        File.directory?("#{working_dir}/.git")
+        run "git fetch origin", cache_directory
+        run "git checkout origin/#{branch}", cache_directory
       end
 
-      def clone
-        run "git clone #{uri} #{working_dir}", false
-      end
+      def checkout(commit)
+        unless File.directory?("#{directory_for(commit)}/.git")
+          run "git clone -ns #{cache_directory} #{directory_for(commit)}"
+        end
 
-      def fetch
-        git "fetch origin"
-      end
+        run "git fetch origin", directory_for(commit)
 
-      def checkout(commit_id)
         # First checkout the branch just in case the commit_id
         # turns out to be HEAD or other non-sha identifier
-        git "checkout origin/#{branch}"
-        git "reset --hard #{commit_id}"
+        run "git checkout origin/#{branch}", directory_for(commit)
+        run "git reset --hard #{commit}", directory_for(commit)
       end
 
-      def git(command)
-        run "git #{command}"
+      def cache_directory
+        File.join(Bob.directory, "cache", path)
       end
     end
   end

data/lib/bob/scm/svn.rb

@@ -17,28 +17,22 @@ module Bob
         $1.to_s
       end
 
-      def with_commit(commit_id)
-        update_code
-        checkout(commit_id)
-        yield
-      end
-
     private
 
-      def update_code
-        initial_checkout unless checked_out?
+      def update_code(commit)
+        initial_checkout(commit) unless checked_out?(commit)
       end
 
       def checkout(revision)
-        run("svn up -q -r#{revision}")
+        run "svn up -q -r#{revision}", directory_for(revision)
       end
 
       def initial_checkout(revision=nil)
-        run("svn co -q #{uri} #{working_dir}")
+        run "svn co -q #{uri} #{directory_for(revision)}"
       end
 
-      def checked_out?
-        File.directory?(working_dir + "/.svn")
+      def checked_out?(commit)
+        File.directory?(directory_for(commit) + "/.svn")
       end
     end
   end

data/lib/bob/test/buildable_stub.rb

@@ -0,0 +1,41 @@
+module Bob
+  module Test
+    BuildableStub = Struct.new(:scm, :uri, :branch, :commit, :build_script) do
+      include Bob::Buildable
+
+      def self.for(repo, commit)
+        scm = (Bob::Test::GitRepo === repo) ? :git : :svn
+        uri =
+          if scm == :git
+            repo.path
+          else
+            "file://#{SvnRepo.server_root}/#{repo.name}"
+          end
+        # move to repo
+        branch = (scm == :git) ? "master" : ""
+        build_script = "./test"
+
+        new(scm, uri, branch, commit, build_script)
+      end
+
+      attr_reader :repo, :status, :output, :commit_info
+
+      def initialize(*args)
+        super
+
+        @status = nil
+        @output = ""
+        @commit_info = {}
+      end
+
+      def start_building(commit_id, commit_info)
+        @commit_info = commit_info
+      end
+
+      def finish_building(commit_id, status, output)
+        @status = status ? :successful : :failed
+        @output = output
+      end
+    end
+  end
+end

data/lib/bob/test/scm/abstract.rb

@@ -0,0 +1,66 @@
+module Bob::Test
+  class AbstractSCMRepo
+    attr_reader :path, :name
+
+    def initialize(name, base_dir=Bob.directory)
+      @name   = name
+      @path   = File.join(base_dir, @name.to_s)
+    end
+
+    def destroy
+      FileUtils.rm_r path if File.directory?(path)
+    end
+
+    def add_commit(message, &action)
+      Dir.chdir(path) do
+        yield action
+        commit(message)
+      end
+    end
+
+    def add_failing_commit
+      add_commit "This commit will fail" do
+        system "echo '#{build_script(false)}' > test"
+        system "chmod +x test"
+        add    "test"
+      end
+    end
+
+    def add_successful_commit
+      add_commit "This commit will work" do
+        system "echo '#{build_script(true)}' > test"
+        system "chmod +x test"
+        add    "test"
+      end
+    end
+
+    def commits
+      raise NotImplementedError
+    end
+
+    def head
+      commits.last[:identifier]
+    end
+
+    protected
+      def add(file)
+        raise NotImplementedError
+      end
+
+      def commit(message)
+        raise NotImplementedError
+      end
+
+      def run(command)
+        system "#{command} &>/dev/null"
+      end
+
+      def build_script(successful=true)
+        <<-script
+#!/bin/sh
+echo "Running tests..."
+exit #{successful ? 0 : 1}
+script
+      end
+  end
+end

data/lib/bob/test/scm/git.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/abstract"
+
+module Bob::Test
+  class GitRepo < AbstractSCMRepo
+    def create
+      FileUtils.mkdir(path)
+
+      Dir.chdir(path) do
+        run "git init"
+        run "git config user.name 'John Doe'"
+        run "git config user.email 'johndoe@example.org'"
+        run "echo 'just a test repo' >> README"
+        add "README"
+        commit "First commit"
+      end
+    end
+
+    def commits
+      Dir.chdir(path) do
+        commits = `git log --pretty=oneline`.collect { |l| l.split(" ").first }
+        commits.inject([]) do |commits, sha1|
+          format  = "---%n:message: >-%n  %s%n:timestamp: %ci%n" +
+            ":identifier: %H%n:author: %n :name: %an%n :email: %ae%n"
+          commits << YAML.load(`git show -s --pretty=format:"#{format}" #{sha1}`)
+        end.reverse
+      end
+    end
+
+    def head
+      Dir.chdir(path) do
+        `git log --pretty=format:%H | head -1`.chomp
+      end
+    end
+
+    def short_head
+      head[0..6]
+    end
+
+    protected
+      def add(file)
+        run "git add #{file}"
+      end
+
+      def commit(message)
+        run %Q{git commit -m "#{message}"}
+      end
+  end
+end

data/lib/bob/test/scm/svn.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + "/abstract"
+require "hpricot"
+
+module Bob::Test
+  class SvnRepo < AbstractSCMRepo
+    def self.server_root
+      @root ||= File.join(Bob.directory, "svn")
+    end
+
+    attr_reader :remote
+
+    def initialize(name, base_dir=Bob.directory)
+      super
+
+      @path   = File.join(base_dir, "svn-#{name}")
+      @remote = File.join(SvnRepo.server_root, name.to_s)
+    end
+
+    def create
+      create_remote
+
+      run "svn checkout file://#{remote} #{path}"
+
+      add_commit("First commit") do
+        run "echo 'just a test repo' >> README"
+        add "README"
+      end
+    end
+
+    def destroy
+      FileUtils.rm_r(remote) if File.directory?(remote)
+      super
+    end
+
+    def commits
+      Dir.chdir(path) do
+        doc = Hpricot::XML(`svn log --xml`)
+
+        (doc/:log/:logentry).inject([]) { |commits, commit|
+          commits << { :identifier => commit["revision"],
+            :message      => commit.at("msg").inner_html,
+            :committed_at => Time.parse(commit.at("date").inner_html) }
+        }.reverse
+      end
+    end
+
+    alias_method :short_head, :head
+
+    protected
+      def add(file)
+        run "svn add #{file}"
+      end
+
+      def commit(message)
+        run %Q{svn commit -m "#{message}"}
+        run "svn up"
+      end
+
+    private
+      def create_remote
+        FileUtils.mkdir(SvnRepo.server_root)
+
+        run "svnadmin create #{remote}"
+
+        File.open(File.join(remote, "conf", "svnserve.conf"), "w") { |f|
+          f.puts "[general]"
+          f.puts "anon-access = write"
+          f.puts "auth-access = write"
+        }
+      end
+  end
+end

data/lib/bob/test.rb

@@ -0,0 +1,4 @@
+require "bob"
+require "bob/test/buildable_stub"
+require "bob/test/scm/git"
+require "bob/test/scm/svn"

data/lib/bob.rb

@@ -13,23 +13,8 @@ require "core_ext/object"
 module Bob
   # Builds the specified <tt>buildable</tt>. This object must understand
   # the API described in the README.
-  #
-  # The second argument will take an array of commit_ids, which should be
-  # strings with the relevant identifier (a SHA1 hash for git repositories,
-  # a numerical revision for svn repositories, etc).
-  #
-  # You can pass :head as a commit identifier to build the latest commit
-  # in the repo. Examples:
-  #
-  #     Bob.build(buildable, :head) # just build the head
-  #     Bob.build(buildable, ["4", "3", "2"]) # build revision 4, 3, and 2
-  #                                           # (in that order)
-  #     Bob.build(buildable, [:head, "a30fb12"]) # build the HEAD and a30fb12
-  #                                              # commits in this repo.
-  def self.build(buildable, commit_ids)
-    Array(commit_ids).each do |commit_id|
-      Builder.new(buildable, commit_id).build
-    end
+  def self.build(buildable)
+    Builder.new(buildable).build
   end
 
   # Directory where the code for the different buildables will be checked out.

data/test/engine/threaded_test.rb

@@ -6,8 +6,6 @@ class ThreadedBobTest < Test::Unit::TestCase
 
     @repo = GitRepo.new(:test_repo)
     @repo.create
-
-    @buildable = BuildableStub.call(@repo)
   end
 
   test "with a successful threaded build" do
@@ -15,18 +13,18 @@ class ThreadedBobTest < Test::Unit::TestCase
 
     repo.add_successful_commit
     commit_id = repo.commits.last[:identifier]
+    buildable = BuildableStub.for(@repo, commit_id)
 
     begin
       Thread.abort_on_exception = true
       Bob.engine = Bob::Engine::Threaded.new(5)
-      Bob.build(buildable, commit_id)
+      buildable.build
       Bob.engine.wait!
 
-      status, output = buildable.builds[commit_id]
-      assert_equal :successful,          status
-      assert_equal "Running tests...\n", output
+      assert_equal :successful,          buildable.status
+      assert_equal "Running tests...\n", buildable.output
 
-      commit = buildable.metadata[commit_id]
+      commit = buildable.commit_info
       assert_equal "This commit will work", commit[:message]
       assert_equal Time.now.min,            commit[:committed_at].min
     ensure

data/test/helper.rb

@@ -18,7 +18,7 @@ class Test::Unit::TestCase
   include Bob
   include Bob::Test
 
-  attr_reader :repo, :buildable
+  attr_reader :repo
 
   def setup
     Bob.logger = Logger.new("/dev/null")
@@ -26,5 +26,6 @@ class Test::Unit::TestCase
     Bob.directory = File.expand_path(File.dirname(__FILE__) + "/../tmp")
 
     FileUtils.rm_rf(Bob.directory) if File.directory?(Bob.directory)
+    FileUtils.mkdir_p(Bob.directory)
   end
 end

data/test/scm/git_test.rb

@@ -6,8 +6,6 @@ class BobGitTest < Test::Unit::TestCase
 
     @repo = GitRepo.new(:test_repo)
     @repo.create
-
-    @buildable = BuildableStub.call(@repo)
   end
 
   def path(uri, branch="master")
@@ -28,58 +26,38 @@ class BobGitTest < Test::Unit::TestCase
 
     commit_id = repo.commits.last[:identifier]
 
-    buildable.build(commit_id)
-
-    status, output = buildable.builds[commit_id]
-    assert_equal :successful,          status
-    assert_equal "Running tests...\n", output
-
-    assert_equal 1, buildable.metadata.length
+    buildable = BuildableStub.for(@repo, commit_id)
+    buildable.build
 
-    commit = buildable.metadata[commit_id]
-    assert_equal "This commit will work", commit[:message]
-    assert commit[:committed_at].is_a?(Time)
+    assert_equal :successful,          buildable.status
+    assert_equal "Running tests...\n", buildable.output
+    assert_equal "This commit will work", buildable.commit_info[:message]
+    assert buildable.commit_info[:committed_at].is_a?(Time)
   end
 
   test "with a failed build" do
     repo.add_failing_commit
 
     commit_id = repo.commits.last[:identifier]
+    buildable = BuildableStub.for(@repo, commit_id)
 
-    buildable.build(commit_id)
-
-    status, output = buildable.builds[commit_id]
-    assert_equal :failed,              status
-    assert_equal "Running tests...\n", output
-
-    assert_equal 1, buildable.metadata.length
-
-    commit = buildable.metadata[commit_id]
-    assert_equal "This commit will fail", commit[:message]
-    assert commit[:committed_at].is_a?(Time)
-  end
-
-  test "with multiple commits" do
-    2.times { repo.add_failing_commit }
-    commits = repo.commits.collect { |c| c[:identifier] }
-
-    buildable.build(commits)
+    buildable.build
 
-    assert_equal 2, commits.length
-    assert_equal 2, buildable.metadata.length
-    assert_equal 2, buildable.builds.length
+    assert_equal :failed,              buildable.status
+    assert_equal "Running tests...\n", buildable.output
+    assert_equal "This commit will fail", buildable.commit_info[:message]
+    assert buildable.commit_info[:committed_at].is_a?(Time)
   end
 
   test "can build the head of a repository" do
     repo.add_failing_commit
     repo.add_successful_commit
 
-    buildable.build(:head)
+    buildable = BuildableStub.for(@repo, :head)
 
-    assert_equal 1, buildable.builds.length
+    buildable.build
 
-    status, output = buildable.builds[repo.head]
-    assert_equal :successful,          status
-    assert_equal "Running tests...\n", output
+    assert_equal :successful,          buildable.status
+    assert_equal "Running tests...\n", buildable.output
   end
 end

data/test/scm/svn_test.rb

@@ -6,8 +6,6 @@ class BobSvnTest < Test::Unit::TestCase
 
     @repo = SvnRepo.new(:test_repo)
     @repo.create
-
-    @buildable = BuildableStub.call(@repo)
   end
 
   def path(uri)
@@ -31,57 +29,35 @@ class BobSvnTest < Test::Unit::TestCase
   test "with a successful build" do
     repo.add_successful_commit
 
-    buildable.build("2")
-
-    assert_equal 1, buildable.metadata.length
-
-    status, output = buildable.builds["2"]
-    assert_equal :successful,          status
-    assert_equal "Running tests...\n", output
+    buildable = BuildableStub.for(@repo, "2")
+    buildable.build
 
-    assert_equal 1, buildable.metadata.length
-
-    commit = buildable.metadata["2"]
-    assert commit[:committed_at].is_a?(Time)
-    assert_equal "This commit will work", commit[:message]
+    assert_equal :successful,          buildable.status
+    assert_equal "Running tests...\n", buildable.output
+    assert_equal "This commit will work", buildable.commit_info[:message]
+    assert buildable.commit_info[:committed_at].is_a?(Time)
   end
 
   test "with a failed build" do
     repo.add_failing_commit
 
-    buildable.build("2")
-
-    status, output = buildable.builds["2"]
-    assert_equal :failed,              status
-    assert_equal "Running tests...\n", output
-
-    assert_equal 1, buildable.metadata.length
+    buildable = BuildableStub.for(@repo, "2")
+    buildable.build
 
-    commit = buildable.metadata["2"]
-    assert commit[:committed_at].is_a?(Time)
-    assert_equal "This commit will fail", commit[:message]
-  end
-
-  test "with multiple commits" do
-    repo.add_successful_commit
-    2.times { repo.add_failing_commit }
-
-    buildable.build(repo.commits.collect { |c| c[:identifier] })
-
-    assert_equal 3, buildable.metadata.length
-    assert_equal 3, buildable.builds.length
+    assert_equal :failed,              buildable.status
+    assert_equal "Running tests...\n", buildable.output
+    assert_equal "This commit will fail", buildable.commit_info[:message]
+    assert buildable.commit_info[:committed_at].is_a?(Time)
   end
 
   test "can build the head of a repository" do
     repo.add_failing_commit
     repo.add_successful_commit
 
-    buildable.build(:head)
-
-    assert_equal 1, buildable.builds.length
+    buildable = BuildableStub.for(@repo, :head)
+    buildable.build
 
-    status, output = buildable.builds["3"]
-    assert_equal :successful,          status
-    assert_equal "Running tests...\n", output
+    assert_equal :successful,          buildable.status
+    assert_equal "Running tests...\n", buildable.output
   end
 end

data/test/test_test.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + "/helper"
+
+class BobTestTest < Test::Unit::TestCase
+  def assert_scm_repo(repo)
+    repo.destroy
+    repo.create
+
+    assert_equal 1, repo.commits.size
+    assert_equal "First commit", repo.commits.first[:message]
+
+    repo.add_failing_commit
+    assert_equal 2, repo.commits.size
+    assert_equal "This commit will fail", repo.commits.last[:message]
+    assert_equal repo.commits.last[:identifier], repo.head
+    assert repo.short_head
+
+    repo.add_successful_commit
+    assert_equal 3, repo.commits.size
+    assert_equal "This commit will work", repo.commits.last[:message]
+    assert_equal repo.commits.last[:identifier], repo.head
+  end
+
+  def test_buildable_stub
+    b = BuildableStub.new(:git, "git://github.com/ry/node", "master", "HEAD", "make")
+
+    assert_equal :git,                       b.scm
+    assert_equal "git://github.com/ry/node", b.uri
+    assert_equal "master",                   b.branch
+    assert_equal "HEAD",                     b.commit
+    assert_equal "make",                     b.build_script
+  end
+
+  def test_scm_repo
+    assert_scm_repo(GitRepo.new(:my_test_project))
+    assert_scm_repo(SvnRepo.new(:my_test_project))
+  end
+
+  def test_buildable_git_repo
+    repo = GitRepo.new(:test_repo)
+    repo.destroy
+    repo.create
+
+    b = BuildableStub.for(repo, repo.head)
+
+    assert_equal :git,                     b.scm
+    assert_equal "#{Bob.directory}/test_repo", b.uri
+    assert_equal "master",                 b.branch
+    assert_equal repo.head,                b.commit
+    assert_equal "./test",                 b.build_script
+  end
+
+  def test_buildable_svn_repo
+    repo = SvnRepo.new(:test_repo)
+    repo.destroy
+    repo.create
+
+    b = BuildableStub.for(repo, repo.head)
+
+    assert_equal :svn,      b.scm
+    assert_equal "",        b.branch
+    assert_equal repo.head, b.commit
+    assert_equal "./test",  b.build_script
+    assert_equal "file://#{Bob.directory}/svn/test_repo", b.uri
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: integrity-bob
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - "Nicol\xC3\xA1s Sanguinetti"
@@ -33,16 +33,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-- !ruby/object:Gem::Dependency 
-  name: sr-bob-test
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 - !ruby/object:Gem::Dependency 
   name: contest
   type: :development
@@ -97,12 +87,18 @@ files:
 - lib/bob/scm/abstract.rb
 - lib/bob/scm/git.rb
 - lib/bob/scm/svn.rb
+- lib/bob/test.rb
+- lib/bob/test/buildable_stub.rb
+- lib/bob/test/scm/abstract.rb
+- lib/bob/test/scm/git.rb
+- lib/bob/test/scm/svn.rb
 - lib/core_ext/object.rb
 - test/bob_test.rb
 - test/engine/threaded_test.rb
 - test/helper.rb
 - test/scm/git_test.rb
 - test/scm/svn_test.rb
+- test/test_test.rb
 has_rdoc: true
 homepage: http://integrityapp.com
 post_install_message: