build_eval 0.0.5 → 0.0.6

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

@@ -1,39 +1,43 @@
 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,74 +1,84 @@
 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,9 +1,11 @@
 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 }
@@ -14,27 +16,29 @@ 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 }
@@ -45,18 +49,20 @@ 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 }
@@ -67,10 +73,12 @@ 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,10 +1,12 @@
 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 }
@@ -15,21 +17,23 @@ 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
@@ -38,25 +42,31 @@ describe BuildEval::Result::ServerResult do
       end
     end
 
-    context 'when some build results are unsuccessful' do
+    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 }
@@ -69,12 +79,14 @@ 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,44 +1,57 @@
 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] }
 
-      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,
@@ -49,12 +62,14 @@ 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,
@@ -65,40 +80,49 @@ 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 }
 
     {
@@ -108,33 +132,45 @@ 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