build_eval 0.0.4 → 0.0.5

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

@@ -1,20 +1,17 @@
 describe BuildEval::Server::CruiseControlResponse do
-
-  let(:raw_response) { double("RawResponse", body: response_body) }
+  let(:raw_response) { double('RawResponse', body: response_body) }
 
   let(:cruise_control_response) { described_class.new(raw_response) }
 
-  describe "#parse_result" do
-
-    let(:build_name)          { "some_build_name" }
+  describe '#parse_result' do
+    let(:build_name)          { 'some_build_name' }
     let(:response_build_name) { build_name }
-    let(:project_selector)    { "//Project[2]" }
+    let(:project_selector)    { '//Project[2]' }
 
     subject { cruise_control_response.parse_result(project_selector) }
 
-    context "when the response is successful, containing projects" do
-
-      let(:latest_build_status) { "Success" }
+    context 'when the response is successful, containing projects' do
+      let(:latest_build_status) { 'Success' }
       let(:response_body) do
         <<-RESPONSE
           <Projects>
@@ -25,31 +22,26 @@ describe BuildEval::Server::CruiseControlResponse do
         RESPONSE
       end
 
-      context "and the selector matches a project" do
-
-        context "and the build name in the response is not a path" do
-
-          it "creates a build result with the build name from the response" do
+      context 'and the selector matches a project' do
+        context 'and the build name in the response is not a path' do
+          it 'creates a build result with the build name from the response' do
             expect(BuildEval::Result::BuildResult).to receive(:create).with(hash_including(build_name: build_name))
 
             subject
           end
-
         end
 
-        context "and the build name in the response is a path" do
-
+        context 'and the build name in the response is a path' do
           let(:response_build_name) { "some/path/to/#{build_name}" }
 
-          it "creates a build result with the build name from the response with the path omitted" do
+          it 'creates a build result with the build name from the response with the path omitted' do
             expect(BuildEval::Result::BuildResult).to receive(:create).with(hash_including(build_name: build_name))
 
             subject
           end
-
         end
 
-        it "creates a build result containing the latest build status" do
+        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))
           )
@@ -57,59 +49,59 @@ describe BuildEval::Server::CruiseControlResponse do
           subject
         end
 
-        it "returns the created result" do
+        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 "and the selector does not match a project" do
-
-        let(:project_selector) { "does_not_match" }
-        let(:error)            { "an error" }
+      context 'and the selector does not match a project' do
+        let(:project_selector) { 'does_not_match' }
+        let(:error)            { 'an error' }
 
         before(:example) { allow(BuildEval::Server::InvalidSelectorError).to receive(:new).and_return(error) }
 
-        it "creates an invalid selector error" do
+        it 'creates an invalid selector error' do
           expect(BuildEval::Server::InvalidSelectorError).to(
             receive(:new).with(raw_response, project_selector).and_return(error)
           )
 
-          subject rescue Exception
+          begin
+            subject
+          rescue
+            Exception
+          end
         end
 
-        it "raises the error" do
+        it 'raises the error' do
           expect { subject }.to raise_error(error)
         end
-
       end
-
     end
 
-    context "when the response is in error" do
-
-      let(:response_body) { { "file" => "not found" }.to_json }
-      let(:error)         { "an error" }
+    context 'when the response is in error' do
+      let(:response_body) { { 'file' => 'not found' }.to_json }
+      let(:error)         { 'an error' }
 
       before(:example) { allow(BuildEval::Server::InvalidSelectorError).to receive(:new).and_return(error) }
 
-      it "creates an invalid selector error" do
+      it 'creates an invalid selector error' do
         expect(BuildEval::Server::InvalidSelectorError).to(
           receive(:new).with(raw_response, project_selector).and_return(error)
         )
 
-        subject rescue Exception
+        begin
+          subject
+        rescue
+          Exception
+        end
       end
 
-      it "raises an invalid selector error" do
+      it 'raises an invalid selector error' do
         expect { subject }.to raise_error(error)
       end
-
     end
-
   end
-
 end

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

@@ -1,97 +1,83 @@
 describe BuildEval::Server::Decorator do
-
-  let(:server) { double("BuildEval::Server::Server") }
+  let(:server) { double('BuildEval::Server::Server') }
 
   let(:decorator) { described_class.new(server) }
 
-  describe "#build_result" do
-
-    let(:build_name) { "some build name" }
+  describe '#build_result' do
+    let(:build_name) { 'some build name' }
 
     subject { decorator.build_result(build_name) }
 
-    it "delegates to the decorated server" do
+    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
-
+    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
+      it 'returns the result' do
         expect(subject).to eql(build_result)
       end
-
     end
 
-    context "when the decorated server raises an error" do
+    context 'when the decorated server raises an error' do
+      before(:example) { allow(server).to receive(:build_result).and_raise('Forced error') }
 
-      before(:example) { allow(server).to receive(:build_result).and_raise("Forced error") }
-
-      it "creates an indeterminate result" do
+      it 'creates an indeterminate result' do
         expect(BuildEval::Result::BuildResult).to receive(:indeterminate).with(build_name)
 
         subject
       end
 
-      it "returns the indeterminate result" do
+      it 'returns the indeterminate result' do
         indeterminate_result = instance_double(BuildEval::Result::BuildResult)
         allow(BuildEval::Result::BuildResult).to receive(:indeterminate).and_return(indeterminate_result)
 
         expect(subject).to eql(indeterminate_result)
       end
-
     end
-
   end
 
-  describe "#monitor" do
-
+  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
+    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
+    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
-
+    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
+      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
-
+    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
+      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/invalid_selector_error_spec.rb

@@ -1,27 +1,23 @@
 describe BuildEval::Server::InvalidSelectorError do
-
-  let(:response_message) { "Some response message" }
-  let(:response)         { double("HttpResponse", message: response_message) }
-  let(:selector)         { "some/selector" }
+  let(:response_message) { 'Some response message' }
+  let(:response)         { double('HttpResponse', message: response_message) }
+  let(:selector)         { 'some/selector' }
 
   let(:error) { described_class.new(response, selector) }
 
-  describe "#message" do
-
+  describe '#message' do
     subject { error.message }
 
-    it "indicates the selector was not matched" do
+    it 'indicates the selector was not matched' do
       expect(subject).to match(/response did not match selector/i)
     end
 
-    it "contains a message describing the response" do
+    it 'contains a message describing the response' do
       expect(subject).to include(response_message)
     end
 
-    it "contains the selector that was invalid" do
+    it 'contains the selector that was invalid' do
       expect(subject).to include(selector)
     end
-
   end
-
 end

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

@@ -1,22 +1,20 @@
-describe BuildEval::Server::Jenkins, "integrating with a response parser", integration: true do
-  include_context "stubbed http interactions"
+describe BuildEval::Server::Jenkins, 'integrating with a response parser', integration: true do
+  include_context 'stubbed http interactions'
 
-  let(:uri) { "https://some.jenkins.server" }
+  let(:uri) { 'https://some.jenkins.server' }
 
   let(:jenkins) { described_class.new(uri: uri) }
 
-  describe "#build_result" do
-
-    let(:build_name) { "some_build_name" }
+  describe '#build_result' do
+    let(:build_name) { 'some_build_name' }
     let(:response)   { instance_double(Net::HTTPResponse, body: response_body) }
 
     subject { jenkins.build_result(build_name) }
 
     before(:example) { allow(http).to receive(:get).and_return(response) }
 
-    context "when the server responds successfully with build results" do
-
-      let(:latest_build_status) { "Failure" }
+    context 'when the server responds successfully with build results' do
+      let(:latest_build_status) { 'Failure' }
       let(:response_body) do
         <<-RESPONSE
          <Projects>
@@ -27,26 +25,23 @@ describe BuildEval::Server::Jenkins, "integrating with a response parser", integ
         RESPONSE
       end
 
-      it "creates a build result containing the build name" do
+      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
+      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
+      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
-
   end
-
 end

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

@@ -1,20 +1,17 @@
 describe BuildEval::Server::Jenkins do
-  include_context "stubbed http interactions"
+  include_context 'stubbed http interactions'
 
-  let(:uri)              { "https://some.jenkins.server" }
+  let(:uri)              { 'https://some.jenkins.server' }
   let(:constructor_args) { { uri: uri } }
 
   let(:jenkins_server) { described_class.new(constructor_args) }
 
-  it_behaves_like "a continuous integration server" do
-
+  it_behaves_like 'a continuous integration server' do
     let(:server) { jenkins_server }
-
   end
 
-  describe "#build_result" do
-
-    let(:build_name)              { "some_build_name" }
+  describe '#build_result' do
+    let(:build_name)              { 'some_build_name' }
     let(:response)                { instance_double(Net::HTTPResponse) }
     let(:build_result)            { instance_double(BuildEval::Result::BuildResult) }
     let(:cruise_control_response) do
@@ -29,42 +26,38 @@ describe BuildEval::Server::Jenkins do
       allow(cruise_control_response).to receive(:parse_result).and_return(build_result)
     end
 
-    it "issues a GET request for the build" do
+    it 'issues a GET request for the build' do
       expect(http).to receive(:get).with("#{uri}/cc.xml")
 
       subject
     end
 
-    it "creates a Cruise Control response containing the GET request response" do
+    it 'creates a Cruise Control response containing the GET request response' do
       expect(BuildEval::Server::CruiseControlResponse).to receive(:new).with(response)
 
       subject
     end
 
-    it "parses the Cruise Control response to return the project with a matching build name" do
+    it 'parses the Cruise Control response to return the project with a matching build name' do
       expect(cruise_control_response).to receive(:parse_result).with(a_string_including(build_name))
 
       subject
     end
 
-    it "returns the parsed build result" do
+    it 'returns the parsed build result' do
       expect(subject).to eql(build_result)
     end
-
   end
 
-    describe "#to_s" do
-
-      subject { jenkins_server.to_s }
-
-      it "returns a string indicating it is a Jenkins server" do
-        expect(subject).to include("Jenkins server")
-      end
-
-      it "returns a string containing the username" do
-        expect(subject).to include(uri)
-      end
+  describe '#to_s' do
+    subject { jenkins_server.to_s }
 
+    it 'returns a string indicating it is a Jenkins server' do
+      expect(subject).to include('Jenkins server')
     end
 
+    it 'returns a string containing the username' do
+      expect(subject).to include(uri)
+    end
+  end
 end

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

@@ -1,15 +1,11 @@
-shared_examples_for "a continuous integration server" do
-
-  describe "constructor" do
-
+shared_examples_for 'a continuous integration server' do
+  describe 'constructor' do
     subject { server }
 
-    it "creates a http object with any provided http configuration options" do
+    it 'creates a http object with any provided http configuration options' do
       expect(BuildEval::Http).to receive(:new).with(constructor_args)
 
       subject
     end
-
   end
-
 end

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

@@ -1,13 +1,12 @@
-describe BuildEval::Server::TeamCity, "integrating with a response parser", integration: true do
-  include_context "stubbed http interactions"
+describe BuildEval::Server::TeamCity, 'integrating with a response parser', integration: true do
+  include_context 'stubbed http interactions'
 
-  let(:uri) { "https://some.teamcity.server" }
+  let(:uri) { 'https://some.teamcity.server' }
 
   let(:team_city_server) { described_class.new(uri: uri) }
 
-  describe "#build_result" do
-
-    let(:build_name)       { "some_build_name" }
+  describe '#build_result' do
+    let(:build_name)       { 'some_build_name' }
     let(:response_message) { nil }
     let(:response_body)    { nil }
     let(:response)         { instance_double(Net::HTTPResponse, message: response_message, body: response_body) }
@@ -16,10 +15,9 @@ describe BuildEval::Server::TeamCity, "integrating with a response parser", inte
 
     before(:example) { allow(http).to receive(:get).and_return(response) }
 
-    context "when the server responds with build results" do
-
-      let(:latest_build_status) { "FAILED" }
-      let(:response_message)    { "OK" }
+    context 'when the server responds with build results' do
+      let(:latest_build_status) { 'FAILED' }
+      let(:response_message)    { 'OK' }
       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">
@@ -30,13 +28,13 @@ describe BuildEval::Server::TeamCity, "integrating with a response parser", inte
         RESPONSE
       end
 
-      it "creates a build result containing the build name" do
+      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
+      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))
         )
@@ -44,29 +42,25 @@ describe BuildEval::Server::TeamCity, "integrating with a response parser", inte
         subject
       end
 
-      it "returns the created result" do
+      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
+    context 'when the server authentication request fails' do
+      let(:response_message) { 'Unauthorized' }
+      let(:response_body)    { 'Incorrect username or password' }
 
-      let(:response_message) { "Unauthorized" }
-      let(:response_body)    { "Incorrect username or password" }
-
-      it "raises an error" do
+      it 'raises an error' do
         expect { subject }.to raise_error(/Unauthorized/)
       end
-
     end
 
-    context "when the build is not found" do
-
-      let(:response_message) { "Not Found"  }
+    context 'when the build is not found' do
+      let(:response_message) { 'Not Found' }
       let(:response_body) do
         <<-BODY
         Error has occurred during request processing (Not Found).
@@ -74,12 +68,9 @@ describe BuildEval::Server::TeamCity, "integrating with a response parser", inte
         BODY
       end
 
-      it "raises an error" do
+      it 'raises an error' do
         expect { subject }.to raise_error(/Not Found/)
       end
-
     end
-
   end
-
 end

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

@@ -1,22 +1,19 @@
 describe BuildEval::Server::TeamCity do
-  include_context "stubbed http interactions"
+  include_context 'stubbed http interactions'
 
-  let(:uri)              { "https://some.teamcity.server" }
-  let(:username)         { "some_username" }
-  let(:password)         { "some_password" }
+  let(:uri)              { 'https://some.teamcity.server' }
+  let(:username)         { 'some_username' }
+  let(:password)         { 'some_password' }
   let(:constructor_args) { { uri: uri, username: username, password: password } }
 
   let(:team_city_server) { described_class.new(constructor_args) }
 
-  it_behaves_like "a continuous integration server" do
-
+  it_behaves_like 'a continuous integration server' do
     let(:server) { team_city_server }
-
   end
 
-  describe "#build_result" do
-
-    let(:build_name)    { "some_build_name" }
+  describe '#build_result' do
+    let(:build_name)    { 'some_build_name' }
     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,32 +21,28 @@ describe BuildEval::Server::TeamCity do
         </builds>
       RESPONSE
     end
-    let(:response)      { instance_double(Net::HTTPResponse, body: response_body) }
+    let(:response) { instance_double(Net::HTTPResponse, body: response_body) }
 
     subject { team_city_server.build_result(build_name) }
 
     before(:example) { allow(http).to receive(:get).and_return(response) }
 
-    it "issues a GET request for the build" do
+    it 'issues a GET request for the build' do
       expect(http).to receive(:get).with("#{uri}/httpAuth/app/rest/buildTypes/id:#{build_name}/builds")
 
       subject
     end
-
   end
 
-  describe "#to_s" do
-
+  describe '#to_s' do
     subject { team_city_server.to_s }
 
-    it "returns a string indicating it is a TeamCity server" do
-      expect(subject).to include("TeamCity")
+    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
+    it 'returns a string containing the uri to the server' do
       expect(subject).to include(uri)
     end
-
   end
-
 end