build_eval 0.0.4 → 0.0.5

data/spec/lib/build_eval/monitor/composite_spec.rb

@@ -1,12 +1,10 @@
 describe BuildEval::Monitor::Composite do
-
   let(:monitors) { (1..2).map { double(BuildEval::Monitor::Base) } }
 
   let(:composite) { described_class.new(*monitors) }
 
-  describe "#evaluate" do
-
-    let(:results) { monitors.map { instance_double("BuildEval::Result") } }
+  describe '#evaluate' do
+    let(:results) { monitors.map { instance_double('BuildEval::Result') } }
 
     subject { composite.evaluate }
 
@@ -14,25 +12,23 @@ describe BuildEval::Monitor::Composite do
       monitors.zip(results) { |monitor, result| allow(monitor).to receive(:evaluate).and_return(result) }
     end
 
-    it "delegates to the monitors" do
+    it 'delegates to the monitors' do
       monitors.each { |monitor| expect(monitor).to receive(:evaluate) }
 
       subject
     end
 
-    it "creates a composite result containing the result of each monitor" do
+    it 'creates a composite result containing the result of each monitor' do
       expect(BuildEval::Result::CompositeResult).to receive(:new).with(results)
 
       subject
     end
 
-    it "returns the composite result" do
+    it 'returns the composite result' do
       composite_result = instance_double(BuildEval::Result::CompositeResult)
       allow(BuildEval::Result::CompositeResult).to receive(:new).and_return(composite_result)
 
       expect(subject).to eql(composite_result)
     end
-
   end
-
 end

data/spec/lib/build_eval/monitor/server_spec.rb

@@ -1,43 +1,39 @@
 describe BuildEval::Monitor::Server do
-
-  let(:server)      { double("BuildEval::Server") }
+  let(:server)      { double('BuildEval::Server') }
   let(:build_names) { (1..3).map { |i| "build##{i}" } }
 
   let(:server_monitor) { described_class.new(server: server, build_names: build_names) }
 
-  describe "#evaluate" do
-
+  describe '#evaluate' do
     let(:results) { build_names.map { instance_double(BuildEval::Result::BuildResult) } }
 
     subject { server_monitor.evaluate }
 
     before(:example) { allow(server).to receive(:build_result).and_return(*results) }
 
-    it "determines build results for builds of interest" do
+    it 'determines build results for builds of interest' do
       build_names.each { |build_name| expect(server).to receive(:build_result).with(build_name) }
 
       subject
     end
 
-    it "composes a server result for the server" do
+    it 'composes a server result for the server' do
       expect(BuildEval::Result::ServerResult).to receive(:new).with(server, anything)
 
       subject
     end
 
-    it "composes a server result containing the results" do
+    it 'composes a server result containing the results' do
       expect(BuildEval::Result::ServerResult).to receive(:new).with(anything, results)
 
       subject
     end
 
-    it "returns the server result" do
+    it 'returns the server result' do
       server_result = instance_double(BuildEval::Result::ServerResult)
       expect(BuildEval::Result::ServerResult).to receive(:new).and_return(server_result)
 
       expect(subject).to eql(server_result)
     end
-
   end
-
 end

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

@@ -1,85 +1,74 @@
 describe BuildEval::Result::BuildResult do
-
-  describe "::create" do
-
-    let(:build_name)  { "Some build name" }
-    let(:status_name) { "SUCCESS" }
+  describe '::create' do
+    let(:build_name)  { 'Some build name' }
+    let(:status_name) { 'SUCCESS' }
 
     subject { described_class.create(build_name: build_name, status_name: status_name) }
 
-    it "returns a result with the provided build name" do
+    it 'returns a result with the provided build name' do
       expect(subject.build_name).to eql(build_name)
-
     end
 
-    it "determines the status with the provided status name" do
+    it 'determines the status with the provided status name' do
       expect(BuildEval::Result::Status).to receive(:find).with(status_name)
 
       subject
     end
 
-    it "returns a result with the determined status" do
+    it 'returns a result with the determined status' do
       status = BuildEval::Result::Status::UNKNOWN
       allow(BuildEval::Result::Status).to receive(:find).and_return(status)
 
       expect(subject.status).to eql(status)
     end
-
   end
 
-  describe "::indeterminate" do
-
-    let(:build_name) { "Some build name" }
+  describe '::indeterminate' do
+    let(:build_name) { 'Some build name' }
 
     subject { described_class.indeterminate(build_name) }
 
-    it "returns a result with the provided build name" do
+    it 'returns a result with the provided build name' do
       expect(subject.build_name).to eql(build_name)
     end
 
-    it "returns a result with an indeterminate status" do
+    it 'returns a result with an indeterminate status' do
       expect(subject.status).to eql(BuildEval::Result::Status::INDETERMINATE)
     end
-
   end
 
-  describe "#unsuccessful?" do
-
+  describe '#unsuccessful?' do
     let(:status)       { instance_double(BuildEval::Result::Status) }
-    let(:build_result) { described_class.create(build_name: "some build", status_name: "some status") }
+    let(:build_result) { described_class.create(build_name: 'some build', status_name: 'some status') }
 
     subject { build_result.unsuccessful? }
 
     before(:example) { allow(BuildEval::Result::Status).to receive(:find).and_return(status) }
 
-    it "delegates to the underlying status" do
+    it 'delegates to the underlying status' do
       allow(status).to receive(:unsuccessful?).and_return(true)
 
       expect(subject).to be(true)
     end
-
   end
 
-  describe "#to_s" do
-
-    let(:build_name)                   { "Some build name" }
-    let(:status_string_representation) { "SUCCESS" }
+  describe '#to_s' do
+    let(:build_name)                   { 'Some build name' }
+    let(:status_string_representation) { 'SUCCESS' }
     let(:status)                       { instance_double(BuildEval::Result::Status, to_s: status_string_representation) }
 
-    let(:build_result) { described_class.create(build_name: build_name, status_name: "some status") }
+    let(:build_result) { described_class.create(build_name: build_name, status_name: 'some status') }
 
     subject { build_result.to_s }
 
     before(:example) { allow(BuildEval::Result::Status).to receive(:find).and_return(status) }
 
-    it "contains the name of the build" do
+    it 'contains the name of the build' do
       expect(subject).to include(build_name)
     end
 
-    it "contains the string representation of the status" do
+    it 'contains the string representation of the status' do
       expect(subject).to include(status_string_representation)
     end
-
   end
-
 end

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

@@ -1,11 +1,9 @@
 describe BuildEval::Result::CompositeResult do
-
-  let(:results) { (1..2).map { double("BuildEval::Result") } }
+  let(:results) { (1..2).map { double('BuildEval::Result') } }
 
   let(:composite_result) { described_class.new(results) }
 
-  describe "#status" do
-
+  describe '#status' do
     let(:statuses) { results.map { instance_double(BuildEval::Result::Status) } }
 
     subject { composite_result.status }
@@ -16,29 +14,27 @@ describe BuildEval::Result::CompositeResult do
 
     before(:example) { allow(BuildEval::Result::Status).to receive(:effective_status) }
 
-    it "determines the status of the results" do
+    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
+    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
+    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
-
+  describe '#unsuccessful' do
     let(:unsuccessful_builds_array) { results.map { (1..3).map { instance_double(BuildEval::Result::BuildResult) } } }
 
     subject { composite_result.unsuccessful }
@@ -49,20 +45,18 @@ describe BuildEval::Result::CompositeResult do
       end
     end
 
-    it "determines the unsuccessful builds from the results" do
+    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
+    it 'returns all unsuccessful builds' do
       expect(subject).to eql(unsuccessful_builds_array.flatten)
     end
-
   end
 
-  describe "#to_s" do
-
+  describe '#to_s' do
     let(:results_string_representations) { (1..results.length).map { |i| "Result #{i}" } }
 
     subject { composite_result.to_s }
@@ -73,12 +67,10 @@ describe BuildEval::Result::CompositeResult do
       end
     end
 
-    it "returns a string containing the string representation of each result" do
+    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

@@ -1,12 +1,10 @@
 describe BuildEval::Result::ServerResult do
-
-  let(:server)        { double("BuildEval::Server") }
+  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
-
+  describe '#status' do
     let(:statuses) { build_results.map { instance_double(BuildEval::Result::Status) } }
 
     subject { server_result.status }
@@ -17,23 +15,21 @@ describe BuildEval::Result::ServerResult do
       end
     end
 
-    it "determines the effective status of the build results" do
+    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
+    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
-
+  describe '#unsuccessful' do
     subject { server_result.unsuccessful }
 
     before(:example) do
@@ -42,31 +38,25 @@ describe BuildEval::Result::ServerResult do
       end
     end
 
-    context "when some build results are unsuccessful" do
-
-      let(:unsuccessful_results) { [ build_results[0], build_results[2] ] }
+    context 'when some build results are unsuccessful' do
+      let(:unsuccessful_results) { [build_results[0], build_results[2]] }
 
-      it "returns the unsuccessful build results" do
+      it 'returns the unsuccessful build results' do
         expect(subject).to eql(unsuccessful_results)
       end
-
     end
 
-    context "when no build results are unsuccessful" do
-
+    context 'when no build results are unsuccessful' do
       let(:unsuccessful_results) { [] }
 
-      it "returns an empty array" do
+      it 'returns an empty array' do
         expect(subject).to eql([])
       end
-
     end
-
   end
 
-  describe "#to_s" do
-
-    let(:server_string_representation)  { "Server description" }
+  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 }
@@ -79,14 +69,12 @@ describe BuildEval::Result::ServerResult do
       end
     end
 
-    it "contains the string representation of the server" do
+    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
+    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/result/status_spec.rb

@@ -1,57 +1,44 @@
 describe BuildEval::Result::Status do
-
-  describe "::find" do
-
+  describe '::find' do
     subject { described_class.find(name) }
 
-    context "when the name exactly matches a status constant name" do
-
-      let(:name) { "UNKNOWN" }
+    context 'when the name exactly matches a status constant name' do
+      let(:name) { 'UNKNOWN' }
 
-      it "returns the constant" do
+      it 'returns the constant' do
         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" }
+    context 'when the name matches a status constant name with different casing' do
+      let(:name) { 'Success' }
 
-      it "returns the constant" do
+      it 'returns the constant' do
         expect(subject).to be(BuildEval::Result::Status::SUCCESS)
       end
-
     end
 
-    context "when the name is completely different from a status constant name" do
-
-      let(:name) { "does_not_match" }
+    context 'when the name is completely different from a status constant name' do
+      let(:name) { 'does_not_match' }
 
-      it "raises an error indicating the name is invalid" do
+      it 'raises an error indicating the name is invalid' do
         expect { subject }.to raise_error("Build status '#{name}' is invalid")
       end
-
     end
-
   end
 
-  describe "::effective_status" do
-
+  describe '::effective_status' do
     subject { described_class.effective_status(statuses) }
 
-    context "when a single status is provided" do
+    context 'when a single status is provided' do
+      let(:statuses) { [BuildEval::Result::Status::UNKNOWN] }
 
-      let(:statuses) { [ BuildEval::Result::Status::UNKNOWN ] }
-
-      it "returns the status" do
+      it 'returns the status' do
         expect(subject).to eql(BuildEval::Result::Status::UNKNOWN)
       end
-
     end
 
-    context "when the statuses are ordered in ascending severity" do
-
+    context 'when the statuses are ordered in ascending severity' do
       let(:statuses) do
         [
           BuildEval::Result::Status::ERROR,
@@ -62,14 +49,12 @@ describe BuildEval::Result::Status do
         ]
       end
 
-      it "returns the most severe status" do
+      it 'returns the most severe status' do
         expect(subject).to eql(BuildEval::Result::Status::ERROR)
       end
-
     end
 
-    context "when the statuses are ordered in descending severity" do
-
+    context 'when the statuses are ordered in descending severity' do
       let(:statuses) do
         [
           BuildEval::Result::Status::SUCCESS,
@@ -80,51 +65,40 @@ describe BuildEval::Result::Status do
         ]
       end
 
-      it "returns the most severe status" do
+      it 'returns the most severe status' do
         expect(subject).to eql(BuildEval::Result::Status::ERROR)
       end
-
     end
-
   end
 
-  describe "#unsuccessful?" do
-
+  describe '#unsuccessful?' do
     subject { status.unsuccessful? }
 
-    context "when the status is SUCCESS" do
-
+    context 'when the status is SUCCESS' do
       let(:status) { BuildEval::Result::Status::SUCCESS }
 
-      it "returns false" do
+      it 'returns false' do
         expect(subject).to be(false)
       end
-
     end
 
     {
-      "UNKNOWN"       => BuildEval::Result::Status::UNKNOWN,
-      "FAILURE"       => BuildEval::Result::Status::FAILURE,
-      "ERROR"         => BuildEval::Result::Status::ERROR,
-      "INDETERMINATE" => BuildEval::Result::Status::INDETERMINATE
+      'UNKNOWN'       => BuildEval::Result::Status::UNKNOWN,
+      'FAILURE'       => BuildEval::Result::Status::FAILURE,
+      'ERROR'         => BuildEval::Result::Status::ERROR,
+      'INDETERMINATE' => BuildEval::Result::Status::INDETERMINATE
     }.each do |name, status|
-
       context "when the status is #{name}" do
-
         let(:status) { status }
 
-        it "returns true" do
+        it 'returns true' do
           expect(subject).to be(true)
         end
-
       end
-
     end
-
   end
 
-  describe "#to_sym" do
-
+  describe '#to_sym' do
     subject { status.to_sym }
 
     {
@@ -134,45 +108,33 @@ describe BuildEval::Result::Status do
       FAILURE:       :failure!,
       ERROR:         :failure!
     }.each do |name, expected_symbol|
-
       context "when the status is #{name}" do
-
         let(:status) { BuildEval::Result::Status.const_get(name) }
 
-        it "returns success!" do
+        it 'returns success!' do
           expect(subject).to eql(expected_symbol)
         end
-
       end
-
     end
-
   end
 
-  describe "#to_s" do
-
+  describe '#to_s' do
     subject { status.to_s }
 
     {
-      SUCCESS:       "succeeded",
-      UNKNOWN:       "unknown",
-      INDETERMINATE: "indeterminate",
-      FAILURE:       "failed",
-      ERROR:         "errored"
+      SUCCESS:       'succeeded',
+      UNKNOWN:       'unknown',
+      INDETERMINATE: 'indeterminate',
+      FAILURE:       'failed',
+      ERROR:         'errored'
     }.each do |name, expected_string|
-
       context "when the status is #{name}" do
-
         let(:status) { BuildEval::Result::Status.const_get(name) }
 
-        it "returns success!" do
+        it 'returns success!' do
           expect(subject).to eql(expected_string)
         end
-
       end
-
     end
-
   end
-
 end