integrity 0.1.8 → 0.1.9.0

data/test/unit/commit_test.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../helpers'
+
+class CommitTest < Test::Unit::TestCase
+  specify "fixture is valid and can be saved" do
+    lambda do
+      commit = Commit.gen
+      commit.save
+
+      commit.should be_valid
+    end.should change(Commit, :count).by(1)
+  end
+
+  describe "Properties" do
+    before(:each) do
+      @commit = Commit.generate(:identifier => "658ba96cb0235e82ee720510c049883955200fa9",
+                                :author => "Nicolás Sanguinetti <contacto@nicolassanguinetti.info>")
+    end
+
+    it "has a commit identifier" do
+      @commit.identifier.should be("658ba96cb0235e82ee720510c049883955200fa9")
+    end
+
+    it "has a short commit identifier" do
+      @commit.short_identifier.should == "658ba96"
+
+      @commit.identifier = "402"
+      @commit.short_identifier.should == "402"
+    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>"
+    end
+
+    it "raises ArgumentError with invalid author" do
+      lambda { Commit.gen(:author => "foo") }.should raise_error(ArgumentError)
+    end
+
+    it "has a commit message" do
+      commit = Commit.gen(:message => "This commit rocks")
+      commit.message.should == "This commit rocks"
+    end
+
+    it "has a commit date" do
+      commit = Commit.gen(:committed_at => Time.utc(2008, 10, 12, 14, 18, 20))
+      commit.committed_at.to_s.should == "2008-10-12T14:18:20+00:00"
+    end
+
+    it "has a human readable status" do
+      commit = Commit.gen(:successful, :identifier => "658ba96cb0235e82ee720510c049883955200fa9")
+      commit.human_readable_status.should be("Built 658ba96 successfully")
+
+      commit = Commit.gen(:failed, :identifier => "658ba96cb0235e82ee720510c049883955200fa9")
+      commit.human_readable_status.should be("Built 658ba96 and failed")
+
+      commit = Commit.gen(:pending, :identifier => "658ba96cb0235e82ee720510c049883955200fa9")
+      commit.human_readable_status.should be("658ba96 hasn't been built yet")
+    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
+      @commit.queue_build
+      @commit.build.should_not be_nil
+    end
+
+    it "ensures the build is saved" do
+      @commit.build.should be_nil
+      @commit.queue_build
+
+      commit = Commit.first(:identifier => @commit.identifier)
+      commit.build.should_not be_nil
+    end
+  end
+end

data/test/unit/helpers_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + "/../helpers"
+
+class BrowsePublicProjectsTest < Test::Unit::TestCase
+  include ::Integrity::Helpers
+
+  test "#pretty_date" do
+    pretty_date(Time.now).should == "today"
+    pretty_date(Time.new - 86400).should == "yesterday"
+
+    pretty_date(Time.mktime(1995, 12, 01)).should == "on Dec 01st"
+    pretty_date(Time.mktime(1995, 12, 21)).should == "on Dec 21st"
+    pretty_date(Time.mktime(1995, 12, 31)).should == "on Dec 31st"
+
+    pretty_date(Time.mktime(1995, 12, 22)).should == "on Dec 22nd"
+    pretty_date(Time.mktime(1995, 12, 22)).should == "on Dec 22nd"
+
+    pretty_date(Time.mktime(1995, 12, 03)).should == "on Dec 03rd"
+    pretty_date(Time.mktime(1995, 12, 23)).should == "on Dec 23rd"
+
+    pretty_date(Time.mktime(1995, 12, 15)).should == "on Dec 15th"
+    pretty_date(Time.mktime(1995, 12, 15)).should == "on Dec 15th"
+    pretty_date(Time.mktime(1995, 12, 15)).should == "on Dec 15th"
+  end
+
+  describe "#push_url_for" do
+    before(:each) do
+      @project = Project.gen(:integrity)
+      Integrity.config[:admin_username] = "admin"
+      Integrity.config[:admin_password] = "test"
+
+      stub(self).request {
+        OpenStruct.new(:url => "http://integrity.example.org:1234")
+      }
+    end
+
+    test "with auth disabled" do
+      Integrity.config[:use_basic_auth] = false
+
+      push_url_for(@project).should == "http://integrity.example.org:1234/integrity/push"
+    end
+
+    test "with auth and hashing enabled" do
+      Integrity.config[:use_basic_auth]      = true
+      Integrity.config[:hash_admin_password] = true
+
+      push_url_for(@project).should == "http://admin:<password>@integrity.example.org:1234/integrity/push"
+    end
+
+    test "with auth enabled and hashing disabled" do
+      Integrity.config[:use_basic_auth]      = true
+      Integrity.config[:hash_admin_password] = false
+
+      push_url_for(@project).should == "http://admin:test@integrity.example.org:1234/integrity/push"
+    end
+  end
+end

data/test/unit/integrity_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + "/../helpers"
+
+class IntegrityTest < Test::Unit::TestCase
+  test "Integrity.new loads configuration from a file" do
+    stub(DataMapper).setup { nil }
+
+    file = File.dirname(__FILE__) + "/../../config/config.sample.yml"
+    Integrity.new(file)
+
+    Integrity.config[:base_uri].should == "http://integrity.domain.tld"
+    Integrity.config[:export_directory].should == "/path/to/scm/exports"
+  end
+
+  specify "config is just a hash" do
+    Integrity.config[:foo] = "bar"
+    Integrity.config[:foo].should == "bar"
+  end
+end

data/test/unit/migrations_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + "/../helpers"
+
+class MigrationsTest < Test::Unit::TestCase
+  def database_adapter
+    DataMapper.repository(:default).adapter
+  end
+
+  def table_exists?(table_name)
+    database_adapter.storage_exists?(table_name)
+  end
+
+  def current_migrations
+    database_adapter.query("SELECT * from migration_info")
+  end
+
+  def load_initial_migration_fixture
+    database_adapter.execute(File.read(File.dirname(__FILE__) +
+      "/../helpers/initial_migration_fixture.sql"))
+  end
+
+  before(:all) do
+    require "integrity/migrations"
+  end
+
+  before(:each) do
+    [Project, Build, Commit, Notifier].each(&:auto_migrate_down!)
+    assert !table_exists?("migration_info") # just to be sure
+  end
+
+  test "upgrading a pre migration database" do
+    util_capture { Integrity.migrate_db }
+
+    current_migrations.should == ["initial", "add_commits"]
+    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
+    load_initial_migration_fixture
+
+    util_capture { Integrity.migrate_db }
+    current_migrations.should == ["initial", "add_commits"]
+
+    sinatra = Project.first(:name => "Sinatra")
+    sinatra.should have(1).commits
+    sinatra.commits.first.should be_successful
+    sinatra.commits.first.output.should =~ /sinatra/
+
+    shout_bot = Project.first(:name => "Shout Bot")
+    shout_bot.should have(1).commits
+    shout_bot.commits.first.should be_failed
+    shout_bot.commits.first.output.should =~ /shout-bot/
+  end
+end

data/test/unit/notifier_test.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + "/../helpers"
+
+class NotifierTest < Test::Unit::TestCase
+  specify "IRC fixture is valid and can be saved" do
+    lambda do
+      Notifier.generate(:irc).tap do |project|
+        project.should be_valid
+        project.save
+      end
+    end.should change(Project, :count).by(1)
+  end
+
+  specify "Twitter fixture is valid and can be saved" do
+    lambda do
+      Notifier.generate(:twitter).tap do |project|
+        project.should be_valid
+        project.save
+      end
+    end.should change(Project, :count).by(1)
+  end
+
+  describe "Properties" do
+    before(:each) do
+      @notifier = Notifier.generate(:irc)
+    end
+
+    it "has a name" do
+      @notifier.name.should == "IRC"
+    end
+
+    it "has a config" do
+      @notifier.config.should == {:uri => "irc://irc.freenode.net/integrity"}
+    end
+  end
+
+  describe "Validation" do
+    it "requires a name" do
+      lambda do
+        Notifier.generate(:irc, :name => nil)
+      end.should_not change(Notifier, :count)
+    end
+
+    it "requires a config" do
+      lambda do
+        Notifier.generate(:irc, :config => nil)
+      end.should_not change(Notifier, :count)
+    end
+
+    it "requires a project" do
+      lambda do
+        Notifier.generate(:irc, :project => nil)
+      end.should_not change(Notifier, :count)
+    end
+
+    it "requires an unique name in project scope" do
+      project = Project.generate
+      irc     = Notifier.gen(:irc, :project => project)
+
+      project.tap { |project| project.notifiers << irc }.save
+
+      lambda do
+        project.tap { |project| project.notifiers << irc }.save
+      end.should_not change(project.notifiers, :count).from(1).to(2)
+
+      lambda { Notifier.gen(:irc) }.should change(Notifier, :count).to(2)
+    end
+  end
+
+  it "knows which notifiers are available" do
+    Notifier.gen(:irc)
+    Notifier.gen(:twitter)
+    Notifier.should have(2).available
+    Notifier.available.should include(Integrity::Notifier::IRC)
+    Notifier.available.should include(Integrity::Notifier::Twitter)
+  end
+
+  it "knows how to notify the world of a build" do
+    irc   = Notifier.generate(:irc)
+    build = Integrity::Build.generate
+    Notifier::IRC.expects(:notify_of_build).with(build, irc.config)
+    irc.notify_of_build(build)
+  end
+
+  describe "Enabling a list of notifiers for a project" do
+    it "creates new notifiers for the project" do
+      project = Project.generate
+      lambda do
+        project.enable_notifiers(["IRC", "Twitter"],
+          {"IRC" => {"uri" => "irc://irc.freenode.net/integrity"},
+           "Twitter" => {"username" => "john"}})
+      end.should change(project.notifiers, :count).from(0).to(2)
+    end
+
+    it "deletes all of previous notifiers" do
+      project = Project.generate(:notifiers => [Notifier.gen(:irc), Notifier.gen(:twitter)])
+      lambda do
+        project.enable_notifiers("IRC", {"IRC" => {:foo => "bar"}})
+        project.reload
+      end.should change(project.notifiers, :count).from(2).to(1)
+    end
+
+    it "does nothing if given nil as the list of notifiers to enable" do
+      lambda { Project.gen.enable_notifiers(nil, {}) }.should_not change(Notifier, :count)
+    end
+
+    it "doesn't destroy any of the other notifiers that exist for other projects" do
+      irc = Notifier.generate(:irc)
+
+      project = Project.gen
+      project.enable_notifiers("IRC", {"IRC" => irc.config})
+
+      lambda do
+        Project.gen.enable_notifiers("IRC", {"IRC" => irc.config})
+      end.should_not change(project.notifiers, :count)
+    end
+  end
+
+  it "requires notifier classes to implement Notifier.to_haml and Notifier#deliver!" do
+    class Blah < Notifier::Base; end
+    lambda { Blah.to_haml }.should raise_error(NoMethodError)
+    lambda { Blah.new(Build.gen, {}).deliver! }.should raise_error(NoMethodError)
+  end
+end

data/test/unit/project_builder_test.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + "/../helpers"
+
+class ProjectBuilderTest < Test::Unit::TestCase
+  before(:all) do
+    Integrity.config[:export_directory] = File.dirname(__FILE__)
+    @directory = Integrity.config[:export_directory] + "/foca-integrity-master"
+    FileUtils.mkdir(@directory)
+  end
+
+  after(:all) do
+    FileUtils.rm_rf(@directory)
+  end
+
+  before(:each) do
+    @project = Integrity::Project.generate(:integrity, :command => "echo 'output!'")
+    ignore_logs!
+  end
+
+  it "creates a new SCM with given project's uri, branch and export_directory" do
+    SCM::Git.expects(:new).with(@project.uri, @project.branch, @directory)
+    ProjectBuilder.new(@project)
+  end
+
+  describe "When building" do
+    before(:each) do
+      @commit = @project.commits.gen(:pending)
+    end
+
+    it "sets the started and completed timestamps" do
+      SCM::Git.any_instance.expects(:with_revision).with(@commit.identifier).yields
+      SCM::Git.any_instance.expects(:info).returns({})
+
+      build = ProjectBuilder.new(@project).build(@commit)
+      build.output.should == "output!\n"
+      build.started_at.should_not be_nil
+      build.completed_at.should_not be_nil
+      build.should be_successful
+    end
+
+    it "ensures completed_at is set, even if something horrible happens" do
+      lambda {
+        SCM::Git.any_instance.expects(:with_revision).with(@commit.identifier).raises
+        SCM::Git.any_instance.expects(:info).returns({})
+
+        build = ProjectBuilder.new(@project).build(@commit)
+        build.started_at.should_not be_nil
+        build.completed_at.should_not be_nil
+        build.should be_failed
+      }.should raise_error
+    end
+
+
+    it "sets the build status to failure when the build command exits with a non-zero status" do
+      @project.update_attributes(:command => "exit 1")
+      SCM::Git.any_instance.expects(:with_revision).with(@commit.identifier).yields
+      SCM::Git.any_instance.expects(:info).returns({})
+
+      build = ProjectBuilder.new(@project).build(@commit)
+      build.should be_failed
+    end
+
+    it "sets the build status to success when the build command exits with a zero status" do
+      @project.update_attributes(:command => "exit 0")
+      SCM::Git.any_instance.expects(:with_revision).with(@commit.identifier).yields
+      SCM::Git.any_instance.expects(:info).returns({})
+
+      build = ProjectBuilder.new(@project).build(@commit)
+      build.should be_successful
+    end
+
+    it "runs the command in the export directory" do
+      @project.update_attributes(:command => "cat foo.txt")
+      File.open(@directory + "/foo.txt", "w") { |file| file << "bar!" }
+      SCM::Git.any_instance.expects(:with_revision).with(@commit.identifier).yields
+      SCM::Git.any_instance.expects(:info).returns({})
+
+      build = ProjectBuilder.new(@project).build(@commit)
+      build.output.should == "bar!"
+    end
+
+    it "captures both stdout and stderr" do
+      @project.update_attributes(:command => "echo foo through out && echo bar through err 1>&2")
+      SCM::Git.any_instance.expects(:with_revision).with(@commit.identifier).yields
+      SCM::Git.any_instance.expects(:info).returns({})
+
+      build = ProjectBuilder.new(@project).build(@commit)
+      build.output.should == "foo through out\nbar through err\n"
+    end
+
+    it "raises SCMUnknownError if it can't figure the scm from the uri" do
+      @project.update_attributes(:uri => "scm://example.org")
+      lambda { ProjectBuilder.new(@project) }.should raise_error(SCM::SCMUnknownError)
+    end
+  end
+
+  describe "When deleting the code from disk" do
+    it "destroys the directory" do
+      lambda do
+        ProjectBuilder.new(@project).delete_code
+      end.should change(Pathname.new(@directory), :directory?).from(true).to(false)
+    end
+
+    it "don't complains if the directory doesn't exists" do
+      Pathname.new(@directory).should_not be_directory
+      lambda { ProjectBuilder.new(@project).delete_code }.should_not raise_error
+    end
+  end
+end