build_eval 0.0.14 → 0.0.15

data/spec/lib/build_eval/server/jenkins_spec.rb

@@ -13,13 +13,14 @@ describe BuildEval::Server::Jenkins do
   describe "#build_result" do
 
     let(:build_name)              { "some_build_name" }
+    let(:branch_name)             { nil }
     let(:response)                { instance_double(Net::HTTPResponse) }
     let(:build_result)            { instance_double(BuildEval::Result::BuildResult) }
     let(:cruise_control_response) do
       instance_double(BuildEval::Server::CruiseControlResponse, parse_result: build_result)
     end
 
-    subject { jenkins_server.build_result(build_name) }
+    subject { jenkins_server.build_result(build_name, branch_name) }
 
     before(:example) do
       allow(http).to receive(:get).and_return(response)

data/spec/lib/build_eval/server/team_city_integration_spec.rb

@@ -8,11 +8,12 @@ describe BuildEval::Server::TeamCity, "integrating with a response parser", inte
   describe "#build_result" do
 
     let(:build_name)       { "some_build_name" }
+    let(:branch_name)      { nil }
     let(:response_message) { nil }
     let(:response_body)    { nil }
     let(:response)         { instance_double(Net::HTTPResponse, message: response_message, body: response_body) }
 
-    subject { team_city_server.build_result(build_name) }
+    subject { team_city_server.build_result(build_name, branch_name) }
 
     before(:example) { allow(http).to receive(:get).and_return(response) }
 

data/spec/lib/build_eval/server/team_city_spec.rb

@@ -15,6 +15,7 @@ describe BuildEval::Server::TeamCity do
   describe "#build_result" do
 
     let(:build_name)    { "some_build_name" }
+    let(:branch_name)   { nil }
     let(:response_body) do
       <<-RESPONSE
         <builds count="3" href="/httpAuth/app/rest/buildTypes/#{build_name}/builds/" nextHref="/httpAuth/app/rest/buildTypes/#{build_name}/builds/?count=3&start=3">
@@ -24,7 +25,7 @@ describe BuildEval::Server::TeamCity do
     end
     let(:response) { instance_double(Net::HTTPResponse, body: response_body) }
 
-    subject { team_city_server.build_result(build_name) }
+    subject { team_city_server.build_result(build_name, branch_name) }
 
     before(:example) { allow(http).to receive(:get).and_return(response) }
 

data/spec/lib/build_eval/server/travis_pro_spec.rb

@@ -9,19 +9,20 @@ describe BuildEval::Server::TravisPro do
   describe "#build_result" do
 
     let(:build_name)        { "some_build_name" }
+    let(:branch_name)       { "some_branch_name" }
     let(:last_build_status) { "Unknown" }
     let(:build_result)      { instance_double(BuildEval::Result::BuildResult) }
 
-    subject { travis_pro_server.build_result(build_name) }
+    subject { travis_pro_server.build_result(build_name, branch_name) }
 
     before(:example) do
       allow(BuildEval::Travis).to receive(:last_build_status).and_return(last_build_status)
       allow(BuildEval::Result::BuildResult).to receive(:create).and_return(build_result)
     end
 
-    it "retrieves the last build status from Travis using the provided GitHub token" do
+    it "retrieves the last build status for the provided branch from Travis using the provided GitHub token" do
       expect(BuildEval::Travis).to(
-        receive(:last_build_status).with(hash_including(github_token: github_token))
+        receive(:last_build_status).with(hash_including(github_token: github_token, branch: branch_name))
       )
 
       subject
@@ -43,10 +44,14 @@ describe BuildEval::Server::TravisPro do
       subject
     end
 
+    it "creates a build result whose branch name is the provided branch" do
+      expect(BuildEval::Result::BuildResult).to receive(:create).with(hash_including(branch_name: branch_name))
+
+      subject
+    end
+
     it "creates a build result whose status is the status the last build status" do
-      expect(BuildEval::Result::BuildResult).to(
-        receive(:create).with(hash_including(status_name: last_build_status))
-      )
+      expect(BuildEval::Result::BuildResult).to receive(:create).with(hash_including(status_name: last_build_status))
 
       subject
     end

data/spec/lib/build_eval/server/travis_spec.rb

@@ -8,19 +8,20 @@ describe BuildEval::Server::Travis do
   describe "#build_result" do
 
     let(:build_name)        { "some_build_name" }
+    let(:branch_name)       { "some_branch_name" }
     let(:last_build_status) { "Failure" }
     let(:build_result)      { instance_double(BuildEval::Result::BuildResult) }
 
-    subject { travis_server.build_result(build_name) }
+    subject { travis_server.build_result(build_name, branch_name) }
 
     before(:example) do
       allow(BuildEval::Travis).to receive(:last_build_status).and_return(last_build_status)
       allow(BuildEval::Result::BuildResult).to receive(:create).and_return(build_result)
     end
 
-    it "retrieves the last build status from Travis for the users build" do
+    it "retrieves the last build status for the provided branch from Travis for the users build" do
       expect(BuildEval::Travis).to(
-        receive(:last_build_status).with(hash_including(repository_path: "#{username}/#{build_name}"))
+        receive(:last_build_status).with(repository_path: "#{username}/#{build_name}", branch: branch_name)
       )
 
       subject
@@ -34,10 +35,14 @@ describe BuildEval::Server::Travis do
       subject
     end
 
+    it "creates a build result whose branch name is the provided branch" do
+      expect(BuildEval::Result::BuildResult).to receive(:create).with(hash_including(branch_name: branch_name))
+
+      subject
+    end
+
     it "creates a build result whose status is the status the last build status" do
-      expect(BuildEval::Result::BuildResult).to(
-        receive(:create).with(hash_including(status_name: last_build_status))
-      )
+      expect(BuildEval::Result::BuildResult).to receive(:create).with(hash_including(status_name: last_build_status))
 
       subject
     end

data/spec/lib/build_eval/travis/session/factory_spec.rb

@@ -0,0 +1,85 @@
+describe BuildEval::Travis::Session::Factory do
+
+  describe "::create" do
+
+    let(:github_token)   { nil }
+    let(:travis_session) { instance_double(::Travis::Client::Session) }
+
+    subject { described_class.create(github_token) }
+
+    before(:example) { allow(::Travis::Client::Session).to receive(:new).and_return(travis_session) }
+
+    shared_examples_for "a factory method creating a new session" do
+
+      it "creates a Travis session with empty SSL settings to avoid using local security certificates" do
+        expect(::Travis::Client::Session).to receive(:new).with(hash_including(ssl: {}))
+
+        subject
+      end
+
+      it "creates a BuildEval session with the Travis session" do
+        expect(BuildEval::Travis::Session::Session).to receive(:new).with(travis_session, anything)
+
+        subject
+      end
+
+      it "creates a BuildEval session with the GitHub token" do
+        expect(BuildEval::Travis::Session::Session).to receive(:new).with(anything, github_token)
+
+        subject
+      end
+
+      it "returns the BuildEval session" do
+        build_eval_session = instance_double(BuildEval::Travis::Session::Session)
+        allow(BuildEval::Travis::Session::Session).to receive(:new).and_return(build_eval_session)
+
+        expect(subject).to equal(build_eval_session)
+      end
+
+    end
+
+    context "when a non-nil GitHub token is provided" do
+
+      let(:github_token)  { "SOMEGITHUBAUTHTOKEN" }
+
+      before(:example) { allow(travis_session).to receive(:github_auth) }
+
+      it_behaves_like "a factory method creating a new session"
+
+      it "creates a Travis session connecting to the Travis Pro site" do
+        expect(::Travis::Client::Session).to receive(:new).with(hash_including(uri: ::Travis::Client::PRO_URI))
+
+        subject
+      end
+
+      it "logs-in using the provided GitHub token via the session" do
+        expect(travis_session).to receive(:github_auth).with(github_token)
+
+        subject
+      end
+
+    end
+
+    context "when a nil GitHub token is provided" do
+
+      let(:github_token)  { nil }
+
+      it_behaves_like "a factory method creating a new session"
+
+      it "creates a Travis session connecting to the Travis Org site" do
+        expect(::Travis::Client::Session).to receive(:new).with(hash_including(uri: ::Travis::Client::ORG_URI))
+
+        subject
+      end
+
+      it "does not log-in" do
+        expect(travis_session).to_not receive(:github_auth)
+
+        subject
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/build_eval/travis/session/pool_spec.rb

@@ -0,0 +1,89 @@
+describe BuildEval::Travis::Session::Pool do
+
+  let(:github_token) { "SOMEGITHUBAUTHTOKEN" }
+
+  let(:session) { instance_double(BuildEval::Travis::Session::Session, github_token: github_token, clear_cache: nil) }
+
+  before(:example) { allow(BuildEval::Travis::Session::Factory).to receive(:create).and_return(session) }
+  after(:example)  { described_class.clear }
+
+  describe "::get" do
+
+    subject { get_session }
+
+    context "when a session for the GitHub token has not been retrieved previously" do
+
+      it "creates a session for the token" do
+        expect(BuildEval::Travis::Session::Factory).to receive(:create).with(github_token)
+
+        subject
+      end
+
+      it "returns the session" do
+        expect(subject).to eql(session)
+      end
+
+    end
+
+    context "when a session for the GitHub token has been retrieved and released" do
+
+      before(:example) do
+        get_session
+        release_session
+      end
+
+      it "does not create a new session" do
+        expect(BuildEval::Travis::Session::Factory).to_not receive(:create)
+
+        subject
+      end
+
+      it "returns the previously created session" do
+        expect(subject).to eql(session)
+      end
+
+    end
+
+    context "when a session for the GitHub token has been retrieved but not released" do
+
+      let(:new_session) { instance_double(BuildEval::Travis::Session::Session) }
+
+      before(:example) { get_session }
+
+      it "creates a session for the token" do
+        expect(BuildEval::Travis::Session::Factory).to receive(:create).with(github_token)
+
+        subject
+      end
+
+      it "returns the newly created session" do
+        allow(BuildEval::Travis::Session::Factory).to receive(:create).and_return(new_session)
+
+        expect(subject).to eql(new_session)
+      end
+
+    end
+
+  end
+
+  describe "::release" do
+
+    subject { release_session }
+
+    it "clears the sessions cache" do
+      expect(session).to receive(:clear_cache)
+
+      subject
+    end
+
+  end
+
+  def release_session
+    described_class.release(session)
+  end
+
+  def get_session
+    described_class.get(github_token)
+  end
+
+end

data/spec/lib/build_eval/travis/session/session_spec.rb

@@ -0,0 +1,24 @@
+describe BuildEval::Travis::Session::Session do
+
+  let(:travis_session) { ::Travis::Client::Session.new(uri: "some/uri", ssl: {}) }
+  let(:github_token)   { "SOMEGITHUBAUTHTOKEN" }
+
+  let(:session) { described_class.new(travis_session, github_token) }
+
+  describe "#github_token" do
+
+    subject { session.github_token }
+
+    it "returns the provided token" do
+      expect(subject).to eql(github_token)
+    end
+
+  end
+
+  it "delegates all other methods to the provided Travis session" do
+    expect(travis_session).to receive(:clear_cache)
+
+    session.clear_cache
+  end
+
+end

data/spec/lib/build_eval/travis/session_spec.rb

@@ -0,0 +1,65 @@
+describe BuildEval::Travis::Session do
+
+  describe "::open" do
+
+    let(:github_token) { "SOMEGITHIBTOKEN" }
+    let(:block)        { lambda { |_session| "Some block" } }
+
+    let(:session) { instance_double(BuildEval::Travis::Session::Session) }
+
+    subject { described_class.open(github_token, &block) }
+
+    before(:example) do
+      allow(BuildEval::Travis::Session::Pool).to receive(:get).and_return(session)
+      allow(BuildEval::Travis::Session::Pool).to receive(:release)
+    end
+
+    it "obtains a session for the provided GitHib token from the pool" do
+      expect(BuildEval::Travis::Session::Pool).to receive(:get).with(github_token)
+
+      subject
+    end
+
+    it "yields the session to the provided block" do
+      expect { |block| described_class.open(github_token, &block) }.to yield_with_args(session)
+
+      subject
+    end
+
+    context "when an error is raised on yield" do
+
+      let(:error) { RuntimeError.new("Forced error") }
+
+      let(:block) { lambda { |_session| raise error } }
+
+      it "returns the session to the pool" do
+        expect(BuildEval::Travis::Session::Pool).to receive(:release).with(session)
+
+        subject rescue nil
+      end
+
+      it "propogates the error" do
+        expect { subject }.to raise_error(error)
+      end
+
+    end
+
+    context "when an error is not raised on yield" do
+
+      let(:block) { lambda { |_session| "Block result" } }
+
+      it "returns the session to the pool" do
+        expect(BuildEval::Travis::Session::Pool).to receive(:release).with(session)
+
+        subject
+      end
+
+      it "returns the last expression from the block" do
+        expect(subject).to eql("Block result")
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/build_eval/travis_spec.rb

@@ -3,23 +3,39 @@ describe BuildEval::Travis do
   describe "::last_build_status" do
 
     let(:repository_path) { "some/repository_path" }
+    let(:branch)          { nil }
     let(:optional_args)   { {} }
+    let(:args)            { { repository_path: repository_path, branch: branch }.merge(optional_args) }
 
-    let(:recent_builds)                   do
-      (1..3).map { |i| instance_double(::Travis::Client::Build, finished?: i > 1) }
-    end
-    let(:last_finished_build)             { recent_builds[1] }
-    let(:last_finished_build_passed_flag) { true }
-    let(:travis_repository)               do
-      instance_double(::Travis::Client::Repository, recent_builds: recent_builds)
-    end
-    let(:travis_session)                  { instance_double(::Travis::Client::Session, repo: travis_repository) }
+    let(:build_color)       { "red" }
+    let(:build)             { instance_double(::Travis::Client::Build, color: build_color) }
+    let(:travis_repository) { instance_double(::Travis::Client::Repository, last_build: build) }
+    let(:travis_session)    { instance_double(::Travis::Client::Session, repo: travis_repository) }
+
+    subject { described_class.last_build_status(args) }
+
+    before(:example) { allow(BuildEval::Travis::Session).to receive(:open).and_yield(travis_session) }
+
+    shared_examples_for "a Travis build whose status is determined" do
+
+      {
+        "green"  => "Success",
+        "yellow" => "Building",
+        "red"    => "Failure"
+      }.each do |color, status|
 
-    subject { described_class.last_build_status({ repository_path: repository_path }.merge(optional_args)) }
+        context "when the builds color is #{color}" do
+
+          let(:build_color) { color }
+
+          it "returns '#{status}'" do
+            expect(subject).to eql(status)
+          end
+
+        end
+
+      end
 
-    before(:example) do
-      allow(BuildEval::Travis::SessionFactory).to receive(:create).and_return(travis_session)
-      allow(last_finished_build).to receive(:passed?).and_return(last_finished_build_passed_flag)
     end
 
     context "when a Github authentication token is provided" do
@@ -27,8 +43,8 @@ describe BuildEval::Travis do
       let(:github_token)  { "SOMEGITHUBAUTHTOKEN" }
       let(:optional_args) { { github_token: github_token } }
 
-      it "creates a Travis session using the token" do
-        expect(BuildEval::Travis::SessionFactory).to receive(:create).with(github_token)
+      it "opens a Travis session using the token" do
+        expect(BuildEval::Travis::Session).to receive(:open).with(github_token)
 
         subject
       end
@@ -39,75 +55,84 @@ describe BuildEval::Travis do
 
       let(:optional_args) { {} }
 
-      it "creates a Travis session for a nil token" do
-        expect(BuildEval::Travis::SessionFactory).to receive(:create).with(nil)
+      it "opens a Travis session for a nil token" do
+        expect(BuildEval::Travis::Session).to receive(:open).with(nil)
 
         subject
       end
 
     end
 
+    context "when an error occurs opening a session" do
 
-    it "retrieves the Travis repository for the provided repository path from the session" do
-      expect(travis_session).to receive(:repo).with(repository_path)
+      before(:example) do
+        allow(BuildEval::Travis::Session).to(
+          receive(:open).and_raise(::Travis::Client::Error.new("Forced error"))
+        )
+      end
+
+      it "returns 'Unknown'" do
+        expect(subject).to eql("Unknown")
+      end
 
-      subject
     end
 
-    it "retrieves the recent builds from the repository" do
-      expect(travis_repository).to receive(:recent_builds)
+    it "retrieves the Travis repository for the provided repository path from the session" do
+      expect(travis_session).to receive(:repo).with(repository_path)
 
       subject
     end
 
-    it "determines if the last finished build has passed" do
-      expect(last_finished_build).to receive(:passed?)
+    context "when a branch is provided" do
 
-      subject
-    end
+      let(:branch) { "some_branch" }
+
+      before(:example) { allow(travis_repository).to receive(:branch).and_return(build) }
 
-    context "when the last finished build passed" do
+      it_behaves_like "a Travis build whose status is determined"
 
-      let(:last_finished_build_passed_flag) { true }
+      it "retrieves the last build for the branch" do
+        expect(travis_repository).to receive(:branch).with(branch)
 
-      it "returns 'Success'" do
-        expect(subject).to eql("Success")
+        subject
       end
 
-    end
+      context "when an error occurs retrieving the last build" do
 
-    context "when the last finished build failed" do
+        before(:example) do
+          allow(travis_repository).to receive(:branch).and_raise(::Travis::Client::Error.new("Forced error"))
+        end
 
-      let(:last_finished_build_passed_flag) { false }
+        it "returns 'Unknown'" do
+          expect(subject).to eql("Unknown")
+        end
 
-      it "returns 'Failure'" do
-        expect(subject).to eql("Failure")
       end
 
     end
 
-    context "when an error occurs obtaining a session" do
+    context "when a branch is not provided" do
 
-      before(:example) do
-        allow(BuildEval::Travis::SessionFactory).to(
-          receive(:create).and_raise(::Travis::Client::Error.new("Forced error"))
-        )
-      end
+      let(:branch) { nil }
 
-      it "returns 'Unknown'" do
-        expect(subject).to eql("Unknown")
+      it_behaves_like "a Travis build whose status is determined"
+
+      it "retrieves the last build repository" do
+        expect(travis_repository).to receive(:last_build)
+
+        subject
       end
 
-    end
+      context "when an error occurs retrieving the last build" do
 
-    context "when an error occurs retrieving the recent builds" do
+        before(:example) do
+          allow(travis_repository).to receive(:last_build).and_raise(::Travis::Client::Error.new("Forced error"))
+        end
 
-      before(:example) do
-        allow(travis_repository).to receive(:recent_builds).and_raise(::Travis::Client::Error.new("Forced error"))
-      end
+        it "returns 'Unknown'" do
+          expect(subject).to eql("Unknown")
+        end
 
-      it "returns 'Unknown'" do
-        expect(subject).to eql("Unknown")
       end
 
     end

data/spec/lib/build_eval_smoke_spec.rb

@@ -1,6 +1,6 @@
 describe BuildEval, "integrating with a real CI server", smoke: true do
 
-  let(:builds)  { BuildEval::Examples::Travis.builds }
+  let(:build_configurations)  { BuildEval::Examples::Travis.build_configurations }
 
   let(:monitor) { BuildEval::Examples::Travis.monitor }
 
@@ -9,6 +9,7 @@ describe BuildEval, "integrating with a real CI server", smoke: true do
     let(:tolerated_statuses) do
       [
         BuildEval::Result::Status::SUCCESS,
+        BuildEval::Result::Status::BUILDING,
         BuildEval::Result::Status::UNKNOWN,
         BuildEval::Result::Status::FAILURE,
         BuildEval::Result::Status::ERROR
@@ -22,8 +23,8 @@ describe BuildEval, "integrating with a real CI server", smoke: true do
     end
 
     it "describes the builds and their individual status" do
-      builds.each do |build|
-        expect(subject.to_s).to match(/#{build}: (#{tolerated_statuses.map(&:to_s).join("|")})/)
+      build_configurations.each do |build_configuration|
+        expect(subject.to_s).to match(/#{build_configuration} -> (#{tolerated_statuses.map(&:to_s).join("|")})/)
       end
     end