alphasights-integrity 0.1.9.8 → 0.1.10

data/test/acceptance/manual_build_project_test.rb

@@ -40,7 +40,7 @@ class ManualBuildProjectTest < Test::Unit::AcceptanceTestCase
     git_repo(:my_test_project).add_successful_commit
     Project.gen(:my_test_project,
                 :uri => git_repo(:my_test_project).path,
-                :command => "ruby not-found.rb")
+                :command => "echo FAIL && exit 1")
 
     login_as "admin", "test"
 
@@ -53,7 +53,7 @@ class ManualBuildProjectTest < Test::Unit::AcceptanceTestCase
     click_button "Update Project"
 
     visit "/my-test-project"
-    click_button "Build the last commit"
+    click_button "Fetch and build"
 
     assert_have_tag("h1", :content => "success")
   end

data/test/acceptance/notifier_test_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + "/../helpers/acceptance"
+require "helpers/acceptance/email_notifier"
+require "helpers/acceptance/textfile_notifier"
+
+require "integrity/notifier/test"
+
+class NotifierTestTest < Test::Unit::TestCase
+  include Integrity::Notifier::Test
+
+  setup do
+    @notifier = Integrity::Notifier::Textfile
+    @config   = {"file" => "/tmp/integrity.txt"}
+
+    FileUtils.rm @config["file"] if File.exists?(@config["file"])
+  end
+
+  def notifier
+    "Textfile"
+  end
+
+  test "it provides a formulary to configure options" do
+    assert provides_option?("file")
+    assert provides_option?("file", @config["file"])
+  end
+
+  test "it sends notification" do
+    build = build(:successful)
+
+    @notifier.notify_of_build(build, @config)
+
+    notification = File.read(@config["file"])
+
+    assert notification.start_with?("===")
+    assert notification.include?(build.commit.identifier)
+    assert notification.include?("successful")
+  end
+end

data/test/acceptance/stylesheet_test.rb

@@ -10,11 +10,12 @@ class IntegrityStylesheetTest < Test::Unit::AcceptanceTestCase
   scenario "browsing on some Integrity install" do
     visit "/"
     assert_have_tag("link[@href='/integrity.css']")
+
     visit "/integrity.css"
 
     assert_contain("body {")
     # TODO: Check that it actually returns a 302
-    assert_equal %Q{"2465c472aacf302259dde5146a841e45"},
+    assert_equal %Q{"de9cf45fa61c8a2bb96c17fc16998599"},
       webrat_session.send(:response).headers["ETag"]
 
     visit "/reset.css"

data/test/helpers.rb

@@ -4,7 +4,6 @@ require "rubygems"
 
 require "test/unit"
 require "rr"
-require "mocha"
 require "dm-sweatshop"
 require "webrat/sinatra"
 
@@ -29,6 +28,7 @@ end
 module TestHelper
   def ignore_logs!
     Integrity.config[:log] = "/tmp/integrity.test.log"
+    Bob.logger = Logger.new("/dev/null")
   end
 
   def capture_stdout
@@ -58,8 +58,9 @@ class Test::Unit::TestCase
 
   before(:all) do
     DataMapper.setup(:default, "sqlite3::memory:")
-
     require "integrity/migrations"
+
+    ignore_logs!
   end
 
   before(:each) do

data/test/unit/build_test.rb

@@ -1,11 +1,7 @@
 require File.dirname(__FILE__) + '/../helpers'
 
 class BuildTest < Test::Unit::TestCase
-  before(:each) do
-    RR.reset
-  end
-
-  specify "fixture is valid and can be saved" do
+  test "fixture is valid and can be saved" do
     lambda do
       build = Build.gen
       build.save
@@ -15,58 +11,27 @@ class BuildTest < Test::Unit::TestCase
   end
 
   describe "Properties" do
-    before(:each) do
-      @build = Build.gen
-    end
-
     it "captures the build's STDOUT/STDERR" do
-      @build.output.should_not be_blank
+      assert ! Build.gen.output.empty?
     end
 
     it "knows if it failed or not" do
-      @build.successful = true
-      @build.should be_successful
-      @build.successful = false
-      @build.should be_failed
+      assert Build.gen(:successful => true).successful?
+      assert ! Build.gen(:successful => false).successful?
     end
 
     it "knows it's status" do
-      @build.successful = true
-      @build.status.should be(:success)
-      @build.successful = false
-      @build.status.should be(:failed)
-    end
-  end
+      assert_equal :success, Build.gen(:successful => true).status
+      assert_equal :failed, Build.gen(:successful => false).status
 
-  describe "Pending builds" do
-    before(:each) do
-      3.of { Build.gen(:started_at => nil) }
-      2.of { Build.gen(:started_at => Time.mktime(2009, 1, 17, 23, 18)) }
-    end
-
-    it "finds builds that need to be built" do
-      Build.should have(3).pending
+      assert_equal :pending, Build.gen(:started_at => nil).status
     end
   end
 
-  describe "Queueing a build" do
-    before(:each) do
-      @commit = Commit.gen
-      stub.instance_of(ProjectBuilder).build(@commit)
-    end
-
-    it "creates an empty Build" do
-      @commit.build.should be_nil
-      Build.queue(@commit)
-      @commit.build.should_not be_nil
-    end
-
-    it "ensures the build is saved" do
-      @commit.build.should be_nil
-      Build.queue(@commit)
+  it "finds pending builds" do
+    3.of { Build.gen(:started_at => nil) }
+    2.of { Build.gen(:started_at => Time.mktime(2009, 1, 17, 23, 18)) }
 
-      commit = Commit.first(:identifier => @commit.identifier)
-      commit.build.should_not be_nil
-    end
+    Build.should have(3).pending
   end
 end

data/test/unit/commit_test.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/../helpers'
 
 class CommitTest < Test::Unit::TestCase
-  specify "fixture is valid and can be saved" do
+  test "fixture is valid and can be saved" do
     lambda do
       commit = Commit.gen
       commit.save
@@ -12,57 +12,66 @@ class CommitTest < Test::Unit::TestCase
 
   describe "Properties" do
     before(:each) do
-      @commit = Commit.generate(:identifier => "658ba96cb0235e82ee720510c049883955200fa9",
-                                :author => "Nicolás Sanguinetti <contacto@nicolassanguinetti.info>")
+      @commit = Commit.gen(
+        :message    => "Initial commit",
+        :identifier => "658ba96cb0235e82ee720510c049883955200fa9",
+        :author     => "Nicolás Sanguinetti <contacto@nicolassanguinetti.info>")
     end
 
     it "has a commit identifier" do
-      @commit.identifier.should be("658ba96cb0235e82ee720510c049883955200fa9")
+      assert_equal "658ba96cb0235e82ee720510c049883955200fa9",
+        @commit.identifier
     end
 
     it "has a short commit identifier" do
-      @commit.short_identifier.should == "658ba96"
+      assert_equal "658ba96", @commit.short_identifier
 
       @commit.identifier = "402"
-      @commit.short_identifier.should == "402"
+      assert_equal "402", @commit.short_identifier
     end
 
     it "has a commit author" do
-      commit = Commit.gen(:author => "Nicolás Sanguinetti <contacto@nicolassanguinetti.info>")
-      commit.author.name.should == "Nicolás Sanguinetti"
-      commit.author.email.should == "contacto@nicolassanguinetti.info"
-      commit.author.full.should == "Nicolás Sanguinetti <contacto@nicolassanguinetti.info>"
+      assert_equal "Nicolás Sanguinetti", @commit.author.name
+      assert_equal "contacto@nicolassanguinetti.info", @commit.author.email
+      assert_equal "Nicolás Sanguinetti <contacto@nicolassanguinetti.info>",
+        @commit.author.to_s
 
-      Commit.gen(:author => nil).author.to_s.should =~ /not loaded/
-    end
-
-    it "raises ArgumentError with invalid author" do
-      lambda { Commit.gen(:author => "foo") }.should raise_error(ArgumentError)
+      assert_equal @commit.author.full, @commit.author.to_s
+      assert_match /not loaded/, Commit.gen(:author => nil).author.to_s
+      assert_raises(ArgumentError) { Commit.gen(:author => "foo") }
     end
 
     it "has a commit message" do
-      commit = Commit.gen(:message => "This commit rocks")
-      commit.message.should == "This commit rocks"
-
-      Commit.gen(:message => nil).message.should =~ /not loaded/
+      assert_equal "Initial commit", @commit.message
+      assert_match /not loaded/, Commit.gen(:message => nil).message
     end
-    
+
     it "normalizes the commit date time to the local timezone" do
       ENV['TZ'] = 'US/Eastern' # -04:00
       time = Time.parse("2009-04-16T02:24:51-07:00")
       commit = Commit.gen(:committed_at => time)
       commit.committed_at.to_s.should == "2009-04-16T05:24:51-04:00"
-    end
-    
+   end
+
     it "has a human readable status" do
-      commit = Commit.gen(:successful, :identifier => "658ba96cb0235e82ee720510c049883955200fa9")
-      commit.human_readable_status.should be("Built 658ba96 successfully")
+      assert_match /^Built (.*?) successfully$/,
+        Commit.gen(:successful).human_readable_status
+
+      assert_match /^Built (.*?) and failed$/,
+        Commit.gen(:failed).human_readable_status
 
-      commit = Commit.gen(:failed, :identifier => "658ba96cb0235e82ee720510c049883955200fa9")
-      commit.human_readable_status.should be("Built 658ba96 and failed")
+      assert_match(/^(.*?) hasn\'t been built yet$/,
+        Commit.gen(:pending).human_readable_status)
 
-      commit = Commit.gen(:pending, :identifier => "658ba96cb0235e82ee720510c049883955200fa9")
-      commit.human_readable_status.should be("658ba96 hasn't been built yet")
+      assert_match(/^(.*?) is being build$/,
+        Commit.gen(:building).human_readable_status)
     end
   end
+
+  it "knows its status" do
+    assert Commit.gen(:successful).successful?
+    assert Commit.gen(:failed).failed?
+    assert Commit.gen(:pending).pending?
+    assert Commit.gen(:building).building?
+  end
 end

data/test/unit/helpers_test.rb

@@ -23,6 +23,15 @@ class BrowsePublicProjectsTest < Test::Unit::TestCase
     @h.pretty_date(Time.mktime(1995, 12, 15)).should == "on Dec 15th"
     @h.pretty_date(Time.mktime(1995, 12, 15)).should == "on Dec 15th"
   end
+  
+  test "#pretty_time" do
+    @h.pretty_time(Time.mktime(1995, 12, 01, 02, 04)).should == "02:04"
+  end
+  
+  test "#pretty_date_time" do
+    datetime = Time.mktime(1995, 12, 01, 02, 04)
+    @h.pretty_date_time(datetime).should == "on Dec 01st @ 02:04" 
+  end
 
   describe "urls" do
     before do
@@ -61,6 +70,13 @@ class BrowsePublicProjectsTest < Test::Unit::TestCase
       }
     end
 
+    test "build commit" do
+      assert_equal "/ci/foo-bar/commits/#{@commit.identifier}/builds",
+        @h.commit_path(@build.commit, :builds)
+      assert_equal "http://example.org/ci/foo-bar/commits/#{@commit.identifier}/builds",
+        @h.commit_url(@build.commit, :builds).to_s
+    end
+
     test "compat" do
       silence_warnings {
         assert_equal @h.build_path(@build), @h.commit_path(@build.commit)

data/test/unit/migrations_test.rb

@@ -31,18 +31,20 @@ class MigrationsTest < Test::Unit::TestCase
   test "upgrading a pre migration database" do
     capture_stdout { Integrity.migrate_db }
 
-    current_migrations.should == ["initial", "add_commits", "add_enabled_column", "add_url_to_commits"]
+    current_migrations.should == ["initial", "add_commits",
+      "add_enabled_column", "nil_commit_metadata",  "add_commit_uri_column"]
     assert table_exists?("integrity_projects")
     assert table_exists?("integrity_builds")
     assert table_exists?("integrity_notifiers")
     assert table_exists?("integrity_commits")
   end
 
-  test "migrating data from initial to add_commits migration" do
+  test "migrating data up from initial to the last migration" do
     load_initial_migration_fixture
-
     capture_stdout { Integrity.migrate_db }
-    current_migrations.should == ["initial", "add_commits", "add_enabled_column", "add_url_to_commits"]
+
+    current_migrations.should == ["initial", "add_commits",
+      "add_enabled_column", "nil_commit_metadata","add_commit_uri_column"]
 
     sinatra = Project.first(:name => "Sinatra")
     sinatra.should have(1).commits

data/test/unit/project_test.rb

@@ -1,12 +1,7 @@
 require File.dirname(__FILE__) + "/../helpers"
 
 class ProjectTest < Test::Unit::TestCase
-  before(:each) do
-    RR.reset
-    ignore_logs!
-  end
-
-  specify "default fixture is valid and can be saved" do
+  test "default fixture is valid and can be saved" do
     lambda do
       Project.generate.tap do |project|
         project.should be_valid
@@ -15,7 +10,7 @@ class ProjectTest < Test::Unit::TestCase
     end.should change(Project, :count).by(1)
   end
 
-  specify "integrity fixture is valid and can be saved" do
+  test "integrity fixture is valid and can be saved" do
     lambda do
       Project.generate(:integrity).tap do |project|
         project.should be_valid
@@ -30,85 +25,86 @@ class ProjectTest < Test::Unit::TestCase
     end
 
     it "has a name" do
-      @project.name.should == "Integrity"
+      assert_equal "Integrity", @project.name
     end
 
     it "has a permalink" do
-      @project.permalink.should == "integrity"
+      assert_equal "integrity", @project.permalink
 
-      @project.tap do |project|
-        project.name = "foo's bar/baz and BACON?!"
-        project.save
-      end.permalink.should == "foos-bar-baz-and-bacon"
+      assert_equal "foos-bar-baz-and-bacon",
+        Project.gen(:name => "foo's bar/baz and BACON?!").permalink
     end
 
     it "has an URI" do
-      @project.uri.should == Addressable::URI.parse("git://github.com/foca/integrity.git")
+      assert_equal "git://github.com/foca/integrity.git",
+        @project.uri.to_s
     end
 
     it "has a branch" do
-      @project.branch.should == "master"
-    end
-
-    specify "branch defaults to master" do
-      Project.new.branch.should == "master"
+      assert_equal "master", @project.branch
+      assert_equal "master", Project.new.branch
     end
 
     it "has a command" do
       # TODO: rename to build_command
-      @project.command.should == "rake"
+      assert_equal "rake", @project.command
+      assert_equal "rake", Project.new.command
     end
 
-    specify "command defaults to 'rake'" do
-      Project.new.command.should == "rake"
-    end
-
-    it "has a building flag" do
-      @project.should_not be_building
-    end
-
-    specify "building flag default to false" do
-      Project.new.should_not be_building
+    it "knows wheter it is being built" do
+      assert ! @project.building?
     end
 
     it "knows it's visibility" do
       # TODO: rename Project#public property to visibility
       # TODO: and have utility method to query its state instead
 
-      Project.new.should be_public
+      assert Project.new.public?
 
-      @project.should be_public
-      @project.tap { |p| p.public = "1" }.should be_public
-      @project.tap { |p| p.public = "0" }.should_not be_public
+      assert @project.public?
+      assert Project.gen(:public => "1").public?
+      assert ! Project.gen(:public => "0").public?
 
-      Project.gen(:public => "false").should be_public
-      Project.gen(:public => "true").should be_public
-      Project.gen(:public => false).should_not be_public
-      Project.gen(:public => nil).should_not be_public
+      assert Project.gen(:public => "false").public?
+      assert Project.gen(:public => "true").public?
+      assert ! Project.gen(:public => false).public?
+      assert ! Project.gen(:public => nil).public?
     end
 
-    it "has a created_at" do
-      @project.created_at.should be_a(DateTime)
-    end
-
-    it "has an updated_at" do
-      @project.updated_at.should be_a(DateTime)
+    it "has created_at and updated_at timestamps" do
+      assert_kind_of DateTime, @project.created_at
+      assert_kind_of DateTime, @project.updated_at
     end
 
     it "knows it's status" do
-      Project.gen(:commits => 1.of{ Commit.gen(:successful) }).status.should == :success
-      Project.gen(:commits => 2.of{ Commit.gen(:successful) }).status.should == :success
-      Project.gen(:commits => 2.of{ Commit.gen(:failed) }).status.should == :failed
-      Project.gen(:commits => 1.of{ Commit.gen(:pending) }).status.should == :pending
-      Project.gen(:commits => []).status.should be_nil
+      assert_equal :success,
+        Project.gen(:commits => 1.of{ Commit.gen(:successful) }).status
+
+      assert_equal :success,
+        Project.gen(:commits => 2.of{ Commit.gen(:successful) }).status
+
+      assert_equal :failed,
+        Project.gen(:commits => 2.of{ Commit.gen(:failed) }).status
+
+      assert_equal :pending,
+        Project.gen(:commits => 1.of{ Commit.gen(:pending) }).status
+
+      assert_equal :blank, Project.gen(:commits => []).status
+
+      assert_equal :building,
+        Project.gen(:commits => 1.of{ Commit.gen(:building) }).status
+
+      commits = 3.of{Commit.gen(:successful)} << Commit.gen(:building)
+      assert Project.gen(:commits => commits).building?
     end
 
-    it "knows it's last build" do
-      Project.gen(:commits => []).last_commit.should be_nil
+    it "knows it's last commuit" do
+      assert Project.gen(:commits => []).last_commit.nil?
 
       commits = 5.of { Commit.gen(:successful) }
       project = Project.gen(:commits => commits)
-      project.last_commit.should == commits.sort_by {|c| c.committed_at }.last
+      assert_equal commits.sort_by {|c| c.committed_at }.last,
+        project.last_commit
     end
   end
 
@@ -145,6 +141,16 @@ class ProjectTest < Test::Unit::TestCase
     end
   end
 
+  it "orders projects by name" do
+    @rails   = Project.gen(:name => "rails",   :public => true)
+    @merb    = Project.gen(:name => "merb",    :public => true)
+    @sinatra = Project.gen(:name => "sinatra", :public => true)
+    @camping = Project.gen(:name => "camping", :public => false)
+
+    Project.all.should == [@camping, @merb, @rails, @sinatra]
+    Project.all(:public => true).should == [@merb, @rails, @sinatra]
+  end
+
   describe "When finding its previous builds" do
     before(:each) do
       @project = Project.generate(:commits => 5.of { Commit.gen })
@@ -180,9 +186,8 @@ class ProjectTest < Test::Unit::TestCase
       @project = Project.generate(:commits => @commits)
     end
 
-    it "destroys itself and tell ProjectBuilder to delete the code from disk" do
+    it "destroys itself" do
       lambda do
-        stub.instance_of(ProjectBuilder).delete_code
         @project.destroy
       end.should change(Project, :count).by(-1)
     end
@@ -212,8 +217,10 @@ class ProjectTest < Test::Unit::TestCase
 
       assert_equal 2,         Notifier.count
       assert_equal 2,         project.enabled_notifiers.count
-      assert_equal "IRC",     project.notifiers.first.name
-      assert_equal "Twitter", project.notifiers.last.name
+      
+      sorted_notifiers = project.notifiers.sort_by{|n| n.name}
+      assert_equal "IRC",     sorted_notifiers.first.name
+      assert_equal "Twitter", sorted_notifiers.last.name
 
       project.update_notifiers(["Twitter"],
           {"IRC"     => {"uri" => "irc://irc.freenode.net/integrity"},
@@ -231,7 +238,7 @@ class ProjectTest < Test::Unit::TestCase
 
       assert_equal 2, @project.notifiers.count
     end
- 
+
     it "disables notifiers that are not included in the list" do
       @project.update_notifiers(["IRC"],
           {"IRC"     => {"uri" => "irc://irc.freenode.net/integrity"},
@@ -303,42 +310,4 @@ class ProjectTest < Test::Unit::TestCase
       assert ! @project.notifies?("Twitter")
     end
   end
-
-  describe "When building a commit" do
-    before(:each) do
-      @commits = 2.of { Commit.gen }
-      @project = Project.gen(:integrity, :commits => @commits)
-      stub.instance_of(ProjectBuilder).build { nil }
-    end
-
-    it "gets the specified commit and creates a pending build for it" do
-      commit = @commits.last
-
-      lambda {
-        @project.build(commit.identifier)
-      }.should change(Build, :count).by(1)
-
-      build = Build.all.last
-      build.commit.should be(commit)
-      build.should be_pending
-
-      commit.should be_pending
-    end
-
-    it "creates an empty commit with the head of the project if passed 'HEAD' (the default)" do
-      mock(@project).head_of_remote_repo { "FOOBAR" }
-
-      lambda {
-        @project.build("HEAD")
-      }.should change(Commit, :count).by(1)
-
-      build = Build.all.last
-      build.commit.should == @project.last_commit
-
-      @project.last_commit.should be_pending
-      @project.last_commit.identifier.should  == "FOOBAR"
-      @project.last_commit.author.name.should == "<Commit author not loaded>"
-      @project.last_commit.message.should     == "<Commit message not loaded>"
-    end
-  end
 end