imbriaco-integrity 0.1.9.2

data/test/unit/project_builder_test.rb

@@ -0,0 +1,118 @@
+require File.dirname(__FILE__) + "/../helpers"
+
+class ProjectBuilderTest < Test::Unit::TestCase
+  before(:all) do
+    unless File.directory?(Integrity.config[:export_directory])
+      FileUtils.mkdir(Integrity.config[:export_directory])
+    end
+
+    @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
+
+    it "doesn't fail if the commit identifier can't be retrieved" do
+      SCM::Git.any_instance.expects(:with_revision).with(@commit.identifier).yields
+      SCM::Git.any_instance.expects(:info).returns(false)
+      lambda {
+        ProjectBuilder.new(@project).build(@commit)
+      }.should_not raise_error
+    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,371 @@
+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
+
+    test "deprecated properties" do
+      silence_warnings {
+        @project.last_build.should      == @project.last_commit
+        @project.previous_builds.should == @project.previous_commits
+      }
+    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 updating its notifiers" do
+    setup do
+      twitter = Notifier.gen(:twitter, :enabled => true)
+      irc     = Notifier.gen(:irc,     :enabled => false)
+
+      @project = Project.gen(:notifiers => [twitter, irc])
+    end
+
+    it "creates and enable the given notifiers" do
+      Notifier.all.destroy!
+
+      project = Project.gen
+      project.update_notifiers(["IRC", "Twitter"],
+          {"IRC"     => {"uri" => "irc://irc.freenode.net/integrity"},
+           "Twitter" => {"username" => "john"}})
+
+      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
+
+      project.update_notifiers(["Twitter"],
+          {"IRC"     => {"uri" => "irc://irc.freenode.net/integrity"},
+           "Twitter" => {"username" => "john"}})
+
+      assert_equal 2, Notifier.count
+      assert ! project.notifies?("IRC")
+      assert   project.notifies?("Twitter")
+    end
+
+    it "creates notifiers present in config even when they're disabled" do
+      @project.update_notifiers(["IRC"],
+        {"IRC"     => {"uri" => "irc://irc.freenode.net/integrity"},
+         "Twitter" => {"username" => "john"}})
+
+      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"},
+           "Twitter" => {"username" => "john"}})
+
+      @project.update_notifiers(["IRC"],
+        {"IRC"     => {"uri" => "irc://irc.freenode.net/integrity"}})
+
+      assert ! @project.notifiers.first(:name => "Twitter").enabled?
+      assert   @project.notifiers.first(:name => "IRC").enabled?
+    end
+
+    it "preserves config of notifiers that are being disabled" do
+      @project.update_notifiers(["IRC"],
+        {"IRC"     => {"uri" => "irc://irc.freenode.net/integrity"},
+          "Twitter" => {"username" => "john"}})
+
+      assert_equal "john",
+        @project.notifiers.first(:name => "Twitter").config["username"]
+    end
+
+    it "does nothing if given nil as the list of notifiers to enable" do
+      lambda { Project.gen.update_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.update_notifiers("IRC", {"IRC" => irc.config})
+
+      lambda {
+        Project.gen.update_notifiers("IRC", {"IRC" => irc.config})
+      }.should_not change(project.notifiers, :count)
+    end
+  end
+
+  describe "When retrieving state about its notifier" do
+    before(:each) do
+      @project = Project.gen
+      @irc     = Notifier.generate(:irc)
+    end
+
+    it "knows which notifiers are enabled" do
+      notifiers = [Notifier.gen(:irc, :enabled => false),
+        Notifier.gen(:twitter, :enabled => true)]
+      project = Project.gen(:notifiers => notifiers)
+
+      assert_equal 1, project.enabled_notifiers.size
+    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 for unknown notifier" do
+      @project.config_for("IRC").should == {}
+    end
+
+    specify "#notifies? is true if the notifier exists and is enabled" do
+      assert ! @project.notifies?("UndefinedNotifier")
+
+      @project.update_attributes(:notifiers =>
+        [ Notifier.gen(:irc, :enabled     => true),
+          Notifier.gen(:twitter, :enabled => false) ])
+
+      assert @project.notifies?("IRC")
+      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 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

data/test/unit/scm_test.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + "/../helpers"
+
+class SCMTest < Test::Unit::TestCase
+  def scm(uri)
+    SCM.new(Addressable::URI.parse(uri), "master", "foo")
+  end
+
+  it "recognizes git URIs" do
+    scm("git://example.org/repo").should be_an(SCM::Git)
+    scm("git@example.org/repo.git").should be_an(SCM::Git)
+    scm("git://example.org/repo.git").should be_an(SCM::Git)
+  end
+
+  it "raises SCMUnknownError if it can't figure the SCM from the URI" do
+    lambda { scm("scm://example.org") }.should raise_error(SCM::SCMUnknownError)
+  end
+
+  it "doesn't need the working tree path for all operations, so it's not required on the constructor" do
+    lambda {
+      SCM.new(Addressable::URI.parse("git://github.com/foca/integrity.git"), "master")
+    }.should_not raise_error
+  end
+
+  describe "SCM::Git::URI" do
+    uris = [
+      "rsync://host.xz/path/to/repo.git/",
+      "rsync://host.xz/path/to/repo.git",
+      "rsync://host.xz/path/to/repo.gi",
+      "http://host.xz/path/to/repo.git/",
+      "https://host.xz/path/to/repo.git/",
+      "git://host.xz/path/to/repo.git/",
+      "git://host.xz/~user/path/to/repo.git/",
+      "ssh://[user@]host.xz[:port]/path/to/repo.git/",
+      "ssh://[user@]host.xz/path/to/repo.git/",
+      "ssh://[user@]host.xz/~user/path/to/repo.git/",
+      "ssh://[user@]host.xz/~/path/to/repo.git",
+      "host.xz:/path/to/repo.git/",
+      "host.xz:~user/path/to/repo.git/",
+      "host.xz:path/to/repo.git",
+      "user@host.xz:/path/to/repo.git/",
+      "user@host.xz:~user/path/to/repo.git/",
+      "user@host.xz:path/to/repo.git",
+      "user@host.xz:path/to/repo",
+      "user@host.xz:path/to/repo.a_git"
+    ]
+
+    uris.each do |uri|
+      it "parses the uri #{uri}" do
+        git_url = SCM::Git::URI.new(uri)
+        git_url.working_tree_path.should == "path-to-repo"
+      end
+    end
+  end
+end

data/views/_commit_info.haml

@@ -0,0 +1,24 @@
+%h1&= commit.human_readable_status
+
+- if commit.failed?
+  %form{ :action => commit_path(commit, :builds), :method => :post }
+    %p.submit
+      %button{ :type => :submit, :title => "Rebuild this commit" }<
+        Rebuild
+
+%blockquote
+  %p&= commit.message
+  %p.meta<
+    %span.who<
+      &== by: #{commit.author.name}
+    |
+    %span.when{ :title => commit.commited_at }<
+      &= pretty_date commit.committed_at
+    |
+    %span.what<
+      &== commit: #{commit.identifier}
+
+%h2 Build Output:
+%pre.output
+  :preserve
+    #{bash_color_codes h(commit.output)}

data/views/build.haml

@@ -0,0 +1,2 @@
+#build{ :class => @commit.status }
+  = partial(:commit_info, :commit => @commit)

data/views/error.haml

@@ -0,0 +1,37 @@
+.error
+  %h1
+    Whatever you do, DON'T PANIC!
+
+  %dl
+    %dt This is what happened:
+    %dd
+      %strong&= @error.message
+      %pre.backtrace= @error.backtrace.join("\n")
+    %dd
+      %strong Query parameters:
+      %pre.query_params= params.inspect
+
+    %dt What can I do?
+    %dd
+      - if @project
+        Is your
+        %a{ :href => project_url(@project, :edit) } config
+        ok?
+      Need
+      %a{ :href => "http://integrityapp.com/configure" } help?
+      Remember to restart Integrity.
+      If you think everything is fine,
+      then drop by our irc channel:
+      %a{ :href => "irc://irc.freenode.org:6667/integrity" } #integrity
+      on freenode, and we'll try to help.
+
+    %dt
+      What the hell is
+      = succeed "?" do
+        %strong Integrity
+    %dd
+      Integrity is your friendly
+      %a{ :href => "http://en.wikipedia.org/wiki/Continuous_integration" } Continuous Integration
+      server. If you want to know more about us, check our website at
+      = succeed "." do
+        %a{ :href => "http://integrityapp.com" } integrityapp.com

data/views/home.haml

@@ -0,0 +1,21 @@
+- if @projects.empty?
+  .blank_slate
+    %p None yet, huh?
+    %h1
+      Why don't you
+      = succeed "?" do
+        %a{ :href => root_path("/new") } create your first project
+- else
+  %ul#projects
+    - @projects.each do |project|
+      %li{ :class => cycle("even", "odd") + ' ' + project.status.to_s }
+        %a{ :href => project_path(project) }&= project.name
+        .meta
+          - if project.building?
+            Building!
+          - elsif project.last_commit.nil?
+            Never built yet
+          - else
+            = project.human_readable_status
+  %p#new
+    %a{ :href => root_path("/new") } Add a new project