build_eval 0.0.1 → 0.0.2

data/spec/lib/build_eval/result/composite_result_spec.rb

@@ -0,0 +1,84 @@
+describe BuildEval::Result::CompositeResult do
+
+  let(:results) { (1..2).map { double("BuildEval::Result") } }
+
+  let(:composite_result) { described_class.new(results) }
+
+  describe "#status" do
+
+    let(:statuses) { results.map { instance_double(BuildEval::Result::Status) } }
+
+    subject { composite_result.status }
+
+    before(:example) do
+      results.zip(statuses).each { |result, status| allow(result).to receive(:status).and_return(status) }
+    end
+
+    before(:example) { allow(BuildEval::Result::Status).to receive(:effective_status) }
+
+    it "determines the status of the results" do
+      results.each { |underlying_array| expect(underlying_array).to receive(:status) }
+
+      subject
+    end
+
+    it "determines the effective status of the result statuses" do
+      expect(BuildEval::Result::Status).to receive(:effective_status).with(statuses)
+
+      subject
+    end
+
+    it "returns the effective status" do
+      effective_status = instance_double(BuildEval::Result::Status)
+      allow(BuildEval::Result::Status).to receive(:effective_status).and_return(effective_status)
+
+      expect(subject).to eql(effective_status)
+    end
+
+  end
+
+  describe "#unsuccessful" do
+
+    let(:unsuccessful_builds_array) { results.map { (1..3).map { instance_double(BuildEval::Result::BuildResult) } } }
+
+    subject { composite_result.unsuccessful }
+
+    before(:example) do
+      results.zip(unsuccessful_builds_array).each do |result, unsuccessful_builds|
+        allow(result).to receive(:unsuccessful).and_return(unsuccessful_builds)
+      end
+    end
+
+    it "determines the unsuccessful builds from the results" do
+      results.each { |result| expect(result).to receive(:unsuccessful) }
+
+      subject
+    end
+
+    it "returns all unsuccessful builds" do
+      expect(subject).to eql(unsuccessful_builds_array.flatten)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    let(:results_string_representations) { (1..results.length).map { |i| "Result #{i}" } }
+
+    subject { composite_result.to_s }
+
+    before(:example) do
+      results.zip(results_string_representations).each do |result, string_representation|
+        allow(result).to receive(:to_s).and_return(string_representation)
+      end
+    end
+
+    it "returns a string containing the string representation of each result" do
+      results_string_representations.each do |string_representation|
+        expect(subject).to include(string_representation)
+      end
+    end
+
+  end
+
+end

data/spec/lib/build_eval/result/server_result_spec.rb

@@ -0,0 +1,92 @@
+describe BuildEval::Result::ServerResult do
+
+  let(:server)        { double("BuildEval::Server") }
+  let(:build_results) { (1..3).map { instance_double(BuildEval::Result::BuildResult) } }
+
+  let(:server_result) { described_class.new(server, build_results) }
+
+  describe "#status" do
+
+    let(:statuses) { build_results.map { instance_double(BuildEval::Result::Status) } }
+
+    subject { server_result.status }
+
+    before(:example) do
+      build_results.zip(statuses).each do |build_result, status|
+        allow(build_result).to receive(:status).and_return(status)
+      end
+    end
+
+    it "determines the effective status of the build results" do
+      expect(BuildEval::Result::Status).to receive(:effective_status).with(statuses)
+
+      subject
+    end
+
+    it "returns the effective status" do
+      status = instance_double(BuildEval::Result::Status)
+      allow(BuildEval::Result::Status).to receive(:effective_status).and_return(status)
+
+      expect(subject).to be(status)
+    end
+
+  end
+
+  describe "#unsuccessful" do
+
+    subject { server_result.unsuccessful }
+
+    before(:example) do
+      build_results.each do |build_result|
+        allow(build_result).to receive(:unsuccessful?).and_return(unsuccessful_results.include?(build_result))
+      end
+    end
+
+    context "when some build results are unsuccessful" do
+
+      let(:unsuccessful_results) { [ build_results[0], build_results[2] ] }
+
+      it "returns the unsuccessful build results" do
+        expect(subject).to eql(unsuccessful_results)
+      end
+
+    end
+
+    context "when no build results are unsuccessful" do
+
+      let(:unsuccessful_results) { [] }
+
+      it "returns an empty array" do
+        expect(subject).to eql([])
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    let(:server_string_representation)  { "Server description" }
+    let(:result_string_representations) { build_results.each_with_index.map { |_, i| "Build result ##{i}" } }
+
+    subject { server_result.to_s }
+
+    before(:example) { allow(server).to receive(:to_s).and_return(server_string_representation) }
+
+    before(:example) do
+      build_results.zip(result_string_representations).each do |build_result, string|
+        allow(build_result).to receive(:to_s).and_return(string)
+      end
+    end
+
+    it "contains the string representation of the server" do
+      expect(subject).to include(server_string_representation)
+    end
+
+    it "contains the string representation of each result" do
+      result_string_representations.each { |string| expect(subject).to include(string) }
+    end
+
+  end
+
+end

data/spec/lib/build_eval/{status_spec.rb → result/status_spec.rb}

@@ -1,4 +1,4 @@
-describe BuildEval::Status do
+describe BuildEval::Result::Status do
 
   describe "::find" do
 
@@ -9,7 +9,17 @@ describe BuildEval::Status do
       let(:name) { "UNKNOWN" }
 
       it "returns the constant" do
-        expect(subject).to be(BuildEval::Status::UNKNOWN)
+        expect(subject).to be(BuildEval::Result::Status::UNKNOWN)
+      end
+
+    end
+
+    context "when the name matches a status constant name with different casing" do
+
+      let(:name) { "Success" }
+
+      it "returns the constant" do
+        expect(subject).to be(BuildEval::Result::Status::SUCCESS)
       end
 
     end
@@ -32,30 +42,40 @@ describe BuildEval::Status do
 
     context "when a single status is provided" do
 
-      let(:statuses) { [ BuildEval::Status::UNKNOWN ] }
+      let(:statuses) { [ BuildEval::Result::Status::UNKNOWN ] }
 
       it "returns the status" do
-        expect(subject).to eql(BuildEval::Status::UNKNOWN)
+        expect(subject).to eql(BuildEval::Result::Status::UNKNOWN)
       end
 
     end
 
     context "when the statuses are ordered in descending severity" do
 
-      let(:statuses) { [ BuildEval::Status::FAILURE, BuildEval::Status::UNKNOWN, BuildEval::Status::SUCCESS ] }
+      let(:statuses) do
+        [ BuildEval::Result::Status::ERROR,
+          BuildEval::Result::Status::FAILURE,
+          BuildEval::Result::Status::UNKNOWN,
+          BuildEval::Result::Status::SUCCESS ]
+      end
 
       it "returns the most severe status" do
-        expect(subject).to eql(BuildEval::Status::FAILURE)
+        expect(subject).to eql(BuildEval::Result::Status::ERROR)
       end
 
     end
 
     context "when the statuses are ordered in ascending severity" do
 
-      let(:statuses) { [ BuildEval::Status::SUCCESS, BuildEval::Status::UNKNOWN, BuildEval::Status::FAILURE ] }
+      let(:statuses) do
+        [ BuildEval::Result::Status::SUCCESS,
+          BuildEval::Result::Status::UNKNOWN,
+          BuildEval::Result::Status::FAILURE,
+          BuildEval::Result::Status::ERROR ]
+      end
 
       it "returns the most severe status" do
-        expect(subject).to eql(BuildEval::Status::FAILURE)
+        expect(subject).to eql(BuildEval::Result::Status::ERROR)
       end
 
     end
@@ -68,7 +88,7 @@ describe BuildEval::Status do
 
     context "when the status is SUCCESS" do
 
-      let(:status) { BuildEval::Status::SUCCESS }
+      let(:status) { BuildEval::Result::Status::SUCCESS }
 
       it "returns false" do
         expect(subject).to be(false)
@@ -77,8 +97,9 @@ describe BuildEval::Status do
     end
 
     {
-      "FAILURE" => BuildEval::Status::FAILURE,
-      "UNKNOWN" => BuildEval::Status::UNKNOWN
+      "UNKNOWN" => BuildEval::Result::Status::UNKNOWN,
+      "FAILURE" => BuildEval::Result::Status::FAILURE,
+      "ERROR"   => BuildEval::Result::Status::ERROR
     }.each do |name, status|
 
       context "when the status is #{name}" do
@@ -99,11 +120,11 @@ describe BuildEval::Status do
 
     subject { status.to_sym }
 
-    { SUCCESS: :success!, FAILURE: :failed!, UNKNOWN: :warning! }.each do |name, expected_symbol|
+    { SUCCESS: :success!, UNKNOWN: :warning!, FAILURE: :failed!, ERROR: :failed! }.each do |name, expected_symbol|
 
       context "when the status is #{name}" do
 
-        let(:status) { BuildEval::Status.const_get(name) }
+        let(:status) { BuildEval::Result::Status.const_get(name) }
 
         it "returns success!" do
           expect(subject).to eql(expected_symbol)
@@ -119,11 +140,11 @@ describe BuildEval::Status do
 
     subject { status.to_s }
 
-    { SUCCESS: "succeeded", FAILURE: "failed", UNKNOWN: "unknown" }.each do |name, expected_string|
+    { SUCCESS: "succeeded", UNKNOWN: "unknown", FAILURE: "failed", ERROR: "errored" }.each do |name, expected_string|
 
       context "when the status is #{name}" do
 
-        let(:status) { BuildEval::Status.const_get(name) }
+        let(:status) { BuildEval::Result::Status.const_get(name) }
 
         it "returns success!" do
           expect(subject).to eql(expected_string)

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

@@ -0,0 +1,97 @@
+describe BuildEval::Server::Decorator do
+
+  let(:server) { double("BuildEval::Server::Server") }
+
+  let(:decorator) { described_class.new(server) }
+
+  describe "#build_result" do
+
+    let(:build_name) { "some build name" }
+
+    subject { decorator.build_result(build_name) }
+
+    it "delegates to the decorated server" do
+      expect(server).to receive(:build_result).with(build_name)
+
+      subject
+    end
+
+    context "when the decorated server returns a result" do
+
+      let(:build_result) { instance_double(BuildEval::Result::BuildResult) }
+
+      before(:example) { allow(server).to receive(:build_result).and_return(build_result) }
+
+      it "returns the result" do
+        expect(subject).to eql(build_result)
+      end
+
+    end
+
+    context "when the decorated server raises an error" do
+
+      before(:example) { allow(server).to receive(:build_result).and_raise("Forced error") }
+
+      it "creates an unknown result" do
+        expect(BuildEval::Result::BuildResult).to receive(:unknown).with(build_name)
+
+        subject
+      end
+
+      it "returns the unknown result" do
+        unknown_build_result = instance_double(BuildEval::Result::BuildResult)
+        allow(BuildEval::Result::BuildResult).to receive(:unknown).and_return(unknown_build_result)
+
+        expect(subject).to eql(unknown_build_result)
+      end
+
+    end
+
+  end
+
+  describe "#monitor" do
+
+    let(:build_names) { (1..3).map { |i| "build##{i}" } }
+
+    subject { decorator.monitor(*build_names) }
+
+    it "creates a server monitor for the decorated server" do
+      expect(BuildEval::Monitor::Server).to receive(:new).with(hash_including(server: server))
+
+      subject
+    end
+
+    it "returns the server monitor" do
+      monitor = instance_double(BuildEval::Monitor::Server)
+      allow(BuildEval::Monitor::Server).to receive(:new).and_return(monitor)
+
+      expect(subject).to eql(monitor)
+    end
+
+    context "when an array of build names is provided" do
+
+      subject { decorator.monitor(build_names) }
+
+      it "creates a server monitor for the provided build names" do
+        expect(BuildEval::Monitor::Server).to receive(:new).with(hash_including(build_names: build_names))
+
+        subject
+      end
+
+    end
+
+    context "when variable argument list of build names is provided" do
+
+      subject { decorator.monitor(*build_names) }
+
+      it "creates a server monitor for the provided build names" do
+        expect(BuildEval::Monitor::Server).to receive(:new).with(hash_including(build_names: build_names))
+
+        subject
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,119 @@
+describe BuildEval::Server::TeamCity do
+
+  let(:uri)      { "https://some.teamcity.server" }
+  let(:username) { "some_username" }
+  let(:password) { "some_password" }
+
+  let(:team_city) { described_class.new(uri: uri, username: username, password: password) }
+
+  describe "#build_result" do
+
+    let(:build_name)       { "some_build_name" }
+    let(:response_code)    { nil }
+    let(:response_message) { nil }
+    let(:response_body)    { nil }
+    let(:response)         do
+      instance_double(Net::HTTPResponse, code: response_code, message: response_message, body: response_body)
+    end
+
+    subject { team_city.build_result(build_name) }
+
+    before(:example) { allow(BuildEval::Http).to receive(:get).and_return(response) }
+
+    it "issues a get request for the build" do
+      expected_uri = "#{uri}/httpAuth/app/rest/buildTypes/id:#{build_name}/builds"
+      expect(BuildEval::Http).to receive(:get).with(expected_uri, anything)
+
+      subject rescue Exception
+    end
+
+    it "issues a get request with the provided basic authentication credentials" do
+      expect(BuildEval::Http).to receive(:get).with(anything, username: username, password: password)
+
+      subject rescue Exception
+    end
+
+    context "when the server responds with build results" do
+
+      let(:response_code)       { "200" }
+      let(:response_message)    { "OK" }
+      let(:latest_build_status) { "FAILED" }
+      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">
+          <build id="87735" buildTypeId="#{build_name}" number="2062" status="#{latest_build_status}" state="finished" href="/httpAuth/app/rest/builds/id:87735" webUrl="#{uri}/viewLog.html?buildId=87735&buildTypeId=#{build_name}"/>
+          <build id="87723" buildTypeId="#{build_name}" number="2061" status="SUCCESS" state="finished" href="/httpAuth/app/rest/builds/id:87723" webUrl="#{uri}/viewLog.html?buildId=87723&buildTypeId=#{build_name}"/>
+          <build id="87658" buildTypeId="#{build_name}" number="2060" status="SUCCESS" state="finished" href="/httpAuth/app/rest/builds/id:87658" webUrl="#{uri}/viewLog.html?buildId=87658&buildTypeId=#{build_name}"/>
+          </builds>
+        RESPONSE
+      end
+
+      it "creates a build result containing the build name" do
+        expect(BuildEval::Result::BuildResult).to receive(:create).with(hash_including(build_name: build_name))
+
+        subject
+      end
+
+      it "creates a build result containing the latest build status" do
+        expect(BuildEval::Result::BuildResult).to(
+          receive(:create).with(hash_including(status_name: latest_build_status))
+        )
+
+        subject
+      end
+
+      it "returns the created result" do
+        build_result = instance_double(BuildEval::Result::BuildResult)
+        allow(BuildEval::Result::BuildResult).to receive(:create).and_return(build_result)
+
+        expect(subject).to eql(build_result)
+      end
+
+    end
+
+    context "when the server authentication request fails" do
+
+      let(:response_code)  { "401" }
+      let(:response_message) { "Unauthorized" }
+      let(:response_body)    { "Incorrect username or password" }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(/Unauthorized/)
+      end
+
+    end
+
+    context "when the build is not found" do
+
+      let(:response_code)    { "404" }
+      let(:response_message) { "Not Found"  }
+      let(:response_body) do
+        <<-BODY
+        Error has occurred during request processing (Not Found).
+        Error: jetbrains.buildServer.server.rest.errors.NotFoundException: No build type nor template is found by id '#{build_name}'.
+        BODY
+      end
+
+      it "raises an error" do
+        expect { subject }.to raise_error(/Not Found/)
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    subject { team_city.to_s }
+
+    it "returns a string indicating it is a TeamCity server" do
+      expect(subject).to include("TeamCity")
+    end
+
+    it "returns a string containing the uri to the server" do
+      expect(subject).to include(uri)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,92 @@
+describe BuildEval::Server::Travis do
+
+  let(:username) { "some_username" }
+
+  let(:travis) { described_class.new(username: username) }
+
+  describe "#build_result" do
+
+    let(:build_name)       { "some_build_name" }
+    let(:response_code)    { nil }
+    let(:response_message) { nil }
+    let(:response_body)    { nil }
+    let(:response)         do
+      instance_double(Net::HTTPResponse, code: response_code, message: response_message, body: response_body)
+    end
+
+    subject { travis.build_result(build_name) }
+
+    before(:example) { allow(BuildEval::Http).to receive(:get).and_return(response) }
+
+    it "issues a get request for the build" do
+      expected_uri = "https://api.travis-ci.org/repositories/#{username}/#{build_name}/cc.xml"
+      expect(BuildEval::Http).to receive(:get).with(expected_uri)
+
+      subject rescue Exception
+    end
+
+    context "when the server responds with build results" do
+
+      let(:response_code)       { "200" }
+      let(:response_message)    { "OK" }
+      let(:latest_build_status) { "Success" }
+      let(:response_body)       do
+        <<-RESPONSE
+          <Projects>
+            <Project name="#{username}/#{build_name}" activity="Sleeping" lastBuildStatus="#{latest_build_status}" lastBuildLabel="2" lastBuildTime="2015-08-13T08:31:27.000+0000" webUrl="https://travis-ci.org/#{username}/#{build_name}" />
+          </Projects>
+        RESPONSE
+      end
+
+      it "creates a build result containing the build name" do
+        expect(BuildEval::Result::BuildResult).to receive(:create).with(hash_including(build_name: build_name))
+
+        subject
+      end
+
+      it "creates a build result containing the latest build status" do
+        expect(BuildEval::Result::BuildResult).to(
+          receive(:create).with(hash_including(status_name: latest_build_status))
+        )
+
+        subject
+      end
+
+      it "returns the created result" do
+        build_result = instance_double(BuildEval::Result::BuildResult)
+        allow(BuildEval::Result::BuildResult).to receive(:create).and_return(build_result)
+
+        expect(subject).to eql(build_result)
+      end
+
+    end
+
+    context "when the build is not found" do
+
+      let(:response_code)    { "404" }
+      let(:response_message) { "Not Found" }
+      let(:response_body)    { { "file" => "not found" }.to_json }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(/Not Found/)
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    subject { travis.to_s }
+
+    it "returns a string indicating it uses the Travis CI service" do
+      expect(subject).to include("Travis CI")
+    end
+
+    it "returns a string containing the username" do
+      expect(subject).to include(username)
+    end
+
+  end
+
+end

data/spec/lib/build_eval_spec.rb

@@ -2,7 +2,7 @@ describe BuildEval do
 
   describe "::server" do
 
-    class BuildEval::CIServer::TestableServer
+    class BuildEval::Server::TestableServer
 
       def initialize(_args)
         # Intentionally blank
@@ -17,28 +17,28 @@ describe BuildEval do
     subject { described_class.server(args) }
 
     it "constructs an instance of the server with the provided type" do
-      expect(BuildEval::CIServer::TestableServer).to receive(:new)
+      expect(BuildEval::Server::TestableServer).to receive(:new)
 
       subject
     end
 
     it "constructs the instance with additional arguments" do
-      expect(BuildEval::CIServer::TestableServer).to receive(:new).with(server_arguments)
+      expect(BuildEval::Server::TestableServer).to receive(:new).with(server_arguments)
 
       subject
     end
 
     it "decorates the server with standard server behaviour" do
-      server = instance_double(BuildEval::CIServer::TestableServer)
-      allow(BuildEval::CIServer::TestableServer).to receive(:new).and_return(server)
-      expect(BuildEval::CIServer::Decorator).to receive(:new).with(server)
+      server = instance_double(BuildEval::Server::TestableServer)
+      allow(BuildEval::Server::TestableServer).to receive(:new).and_return(server)
+      expect(BuildEval::Server::Decorator).to receive(:new).with(server)
 
       subject
     end
 
     it "returns the decorated server" do
-      server_decorator = instance_double(BuildEval::CIServer::Decorator)
-      allow(BuildEval::CIServer::Decorator).to receive(:new).and_return(server_decorator)
+      server_decorator = instance_double(BuildEval::Server::Decorator)
+      allow(BuildEval::Server::Decorator).to receive(:new).and_return(server_decorator)
 
       expect(subject).to eql(server_decorator)
     end