foca-integrity 0.1.8 → 0.1.9.0

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

data/test/unit/project_test.rb

@@ -0,0 +1,282 @@
+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
+    lambda do
+      Project.generate.tap do |project|
+        project.should be_valid
+        project.save
+      end
+    end.should change(Project, :count).by(1)
+  end
+
+  specify "integrity fixture is valid and can be saved" do
+    lambda do
+      Project.generate(:integrity).tap do |project|
+        project.should be_valid
+        project.save
+      end
+    end.should change(Project, :count).by(1)
+  end
+
+  describe "Properties" do
+    before(:each) do
+      @project = Project.generate(:integrity)
+    end
+
+    it "has a name" do
+      @project.name.should == "Integrity"
+    end
+
+    it "has a permalink" do
+      @project.permalink.should == "integrity"
+
+      @project.tap do |project|
+        project.name = "foo's bar/baz and BACON?!"
+        project.save
+      end.permalink.should == "foos-bar-baz-and-bacon"
+    end
+
+    it "has an URI" do
+      @project.uri.should == Addressable::URI.parse("git://github.com/foca/integrity.git")
+    end
+
+    it "has a branch" do
+      @project.branch.should == "master"
+    end
+
+    specify "branch defaults to master" do
+      Project.new.branch.should == "master"
+    end
+
+    it "has a command" do
+      # TODO: rename to build_command
+      @project.command.should == "rake"
+    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
+    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
+
+      @project.should be_public
+      @project.tap { |p| p.public = "1" }.should be_public
+      @project.tap { |p| p.public = "0" }.should_not be_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
+    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)
+    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
+    end
+
+    it "knows it's last build" do
+      Project.gen(:commits => []).last_commit.should be_nil
+
+      commits = 5.of { Commit.gen(:successful) }
+      project = Project.gen(:commits => commits)
+      project.last_commit.should == commits.sort_by {|c| c.committed_at }.last
+    end
+  end
+
+  describe "Validation" do
+    it "requires a name" do
+      lambda do
+        Project.gen(:name => nil).should_not be_valid
+      end.should_not change(Project, :count)
+    end
+
+    it "requires an URI" do
+      lambda do
+        Project.gen(:uri => nil).should_not be_valid
+      end.should_not change(Project, :count)
+    end
+
+    it "requires a branch" do
+      lambda do
+        Project.gen(:branch => nil).should_not be_valid
+      end.should_not change(Project, :count)
+    end
+
+    it "requires a command" do
+      lambda do
+        Project.gen(:command => nil).should_not be_valid
+      end.should_not change(Project, :count)
+    end
+
+    it "ensures its name is unique" do
+      Project.gen(:name => "Integrity")
+      lambda do
+        Project.gen(:name => "Integrity").should_not be_valid
+      end.should_not change(Project, :count)
+    end
+  end
+
+  describe "Finding public or private projects" do
+    before(:each) do
+      @public_project = Project.gen(:public => true)
+      @private_project = Project.gen(:public => false)
+    end
+
+    it "finds only public projects if the condition passed is false" do
+      projects = Project.only_public_unless(false)
+      projects.should_not include(@private_project)
+      projects.should include(@public_project)
+    end
+
+    it "finds both private and public projects if the condition passed is true" do
+      projects = Project.only_public_unless(true)
+      projects.should include(@private_project)
+      projects.should include(@public_project)
+    end
+  end
+
+  describe "When finding its previous builds" do
+    before(:each) do
+      @project = Project.generate(:commits => 5.of { Commit.gen })
+      @commits = @project.commits.sort_by {|c| c.committed_at }.reverse
+    end
+
+    it "has 4 previous builds" do
+      @project.should have(4).previous_commits
+    end
+
+    it "returns the builds ordered chronogicaly (desc) by creation date" do
+      @project.previous_commits.should == @commits[1..-1]
+    end
+
+    it "excludes the last build" do
+      @project.previous_commits.should_not include(@project.last_commit)
+    end
+
+    it "returns an empty array if it has only one build" do
+      project = Project.gen(:commits => 1.of { Integrity::Commit.gen })
+      project.should have(:no).previous_commits
+    end
+
+    it "returns an empty array if there are no builds" do
+      project = Project.gen(:commits => [])
+      project.should have(:no).previous_commits
+    end
+  end
+
+  describe "When getting destroyed" do
+    before(:each) do
+      @commits  = 7.of { Commit.gen }
+      @project = Project.generate(:commits => @commits)
+    end
+
+    it "destroys itself and tell ProjectBuilder to delete the code from disk" do
+      lambda do
+        stub.instance_of(ProjectBuilder).delete_code
+        @project.destroy
+      end.should change(Project, :count).by(-1)
+    end
+
+    it "destroys its builds" do
+      lambda do
+        @project.destroy
+      end.should change(Commit, :count).by(-7)
+    end
+  end
+
+  describe "When retrieving state about its notifier" do
+    before(:each) do
+      @project = Project.generate
+      @irc     = Notifier.generate(:irc)
+    end
+
+    specify "#config_for returns given notifier's configuration" do
+      @project.update_attributes(:notifiers => [@irc])
+      @project.config_for("IRC").should == {:uri => "irc://irc.freenode.net/integrity"}
+    end
+
+    specify "#config_for returns an empty hash if no such notifier" do
+      @project.config_for("IRC").should == {}
+    end
+
+    specify "#notifies? is true if it uses the given notifier" do
+      @project.update_attributes(:notifiers => [@irc])
+      @project.notifies?("IRC").should == true
+    end
+
+    specify "#notifies? is false if it doesnt use the given notifier" do
+      @project.update_attributes(:notifiers => [])
+
+      @project.notifies?("IRC").should == false
+      @project.notifies?("UndefinedNotifier").should == false
+    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 be(@project.last_commit)
+
+      @project.last_commit.should be_pending
+      @project.last_commit.identifier.should be("FOOBAR")
+
+      @project.last_commit.author.name.should == "<Commit author not loaded>"
+      @project.last_commit.message.should == "<Commit message not loaded>"
+    end
+  end
+end