build_eval 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1daad2c7e52f801829e07f22003bf4536cf91a51
-  data.tar.gz: 3ab822f2da5e6cad9f5a22d5f0a9b5368d162b98
+  metadata.gz: fa95400e5a67ae6b5f26bd9ba13beffcb74a13c2
+  data.tar.gz: 0d474510b5011073f58d9d8b4fd77e6fab554ee2
 SHA512:
-  metadata.gz: a35303425c8ac6b5cec64f15ae1daec79c08cafa96d2193a8e75ea7f701fc05144dc898a81f232df11d8888ca440f8f55257da4d2c1d880263925cda502ff1c8
-  data.tar.gz: 12d7ceb5d11e619699da7cc19965e8accecd442bddae5e4b81692b8434bcbebcfe6e038972cd16075bf686d434b41862e2fd7f145bbedc65f03475b975902b05
+  metadata.gz: 860cd65effbb7b85d0e763f4bce1fb8867701f4c0b32d25d722b8a119499b0cf652605181c44a79e73e4aae57af6427e7354d82ed11a0902863a3d7839211c2c
+  data.tar.gz: 6e5f3bc2867e832c8a80ddfd924ff4000ec056f95ef148594ef7407fbb010102d7f5e407504dad5a5a6d514ef9e209ed0ad90d83d511bb87eba19ae476848744

data/lib/build_eval/http.rb

@@ -0,0 +1,16 @@
+module BuildEval
+
+  class Http
+
+    def self.get(uri_string, basic_auth=nil)
+      uri = URI.parse(uri_string)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request.basic_auth(basic_auth[:username], basic_auth[:password]) if basic_auth
+        http.request(request)
+      end
+    end
+
+  end
+
+end

data/lib/build_eval/monitor/base.rb

@@ -0,0 +1,13 @@
+module BuildEval
+  module Monitor
+
+    class Base
+
+      def +(monitor)
+        BuildEval::Monitor::Composite.new(self, monitor)
+      end
+
+    end
+
+  end
+end

data/lib/build_eval/monitor/composite.rb

@@ -0,0 +1,17 @@
+module BuildEval
+  module Monitor
+
+    class Composite < BuildEval::Monitor::Base
+
+      def initialize(*monitors)
+        @monitors = monitors
+      end
+
+      def evaluate
+        BuildEval::Result::CompositeResult.new(@monitors.map(&:evaluate))
+      end
+
+    end
+
+  end
+end

data/lib/build_eval/monitor/server.rb

@@ -0,0 +1,18 @@
+module BuildEval
+  module Monitor
+
+    class Server < BuildEval::Monitor::Base
+
+      def initialize(args)
+        @server      = args[:server]
+        @build_names = args[:build_names]
+      end
+
+      def evaluate
+        build_results = @build_names.map { |build_name| @server.build_result(build_name) }
+        BuildEval::Result::ServerResult.new(@server, build_results)
+      end
+
+    end
+  end
+end

data/lib/build_eval/result/build_result.rb

@@ -0,0 +1,41 @@
+module BuildEval
+  module Result
+
+    class BuildResult
+
+      class << self
+
+        def create(args)
+          self.new(build_name: args[:build_name], status: BuildEval::Result::Status.find(args[:status_name]))
+        end
+
+        def unknown(build_name)
+          self.new(build_name: build_name, status: BuildEval::Result::Status::UNKNOWN)
+        end
+
+      end
+
+      attr_reader :build_name
+      attr_reader :status
+
+      private
+
+      def initialize(args)
+        @build_name = args[:build_name]
+        @status     = args[:status]
+      end
+
+      public
+
+      def unsuccessful?
+        @status.unsuccessful?
+      end
+
+      def to_s
+        "#{@build_name}: #{@status}"
+      end
+
+    end
+
+  end
+end

data/lib/build_eval/result/composite_result.rb

@@ -0,0 +1,25 @@
+module BuildEval
+  module Result
+
+    class CompositeResult
+
+      def initialize(results)
+        @results = results
+      end
+
+      def status
+        BuildEval::Result::Status.effective_status(@results.map(&:status))
+      end
+
+      def unsuccessful
+        @results.map(&:unsuccessful).flatten
+      end
+
+      def to_s
+        @results.map(&:to_s).join("\n")
+      end
+
+    end
+
+  end
+end

data/lib/build_eval/result/server_result.rb

@@ -0,0 +1,26 @@
+module BuildEval
+  module Result
+
+    class ServerResult
+
+      def initialize(server, build_results)
+        @server        = server
+        @build_results = build_results
+      end
+
+      def status
+        BuildEval::Result::Status.effective_status(@build_results.map(&:status))
+      end
+
+      def unsuccessful
+        @build_results.find_all(&:unsuccessful?)
+      end
+
+      def to_s
+        "#{@server}: #{@build_results.map(&:to_s).join(", ")}"
+      end
+
+    end
+
+  end
+end

data/lib/build_eval/result/status.rb

@@ -0,0 +1,54 @@
+module BuildEval
+  module Result
+
+    class Status
+
+      private
+
+      def initialize(args)
+        @severity    = args[:severity]
+        @symbol      = args[:symbol]
+        @description = args[:description]
+      end
+
+      public
+
+      SUCCESS = self.new(severity: 0, symbol: :success!, description: "succeeded")
+      UNKNOWN = self.new(severity: 1, symbol: :warning!, description: "unknown")
+      FAILURE = self.new(severity: 2, symbol: :failed!,  description: "failed")
+      ERROR   = self.new(severity: 3, symbol: :failed!,  description: "errored")
+
+      class << self
+
+        def find(name)
+          begin
+            self.const_get(name.upcase)
+          rescue NameError
+            raise "Build status '#{name}' is invalid"
+          end
+        end
+
+        def effective_status(statuses)
+          statuses.sort_by { |status| status.severity }.last
+        end
+
+      end
+
+      attr_reader :severity
+
+      def unsuccessful?
+        self != SUCCESS
+      end
+
+      def to_sym
+        @symbol
+      end
+
+      def to_s
+        @description
+      end
+
+    end
+
+  end
+end

data/lib/build_eval/{ci_server → server}/decorator.rb

@@ -1,5 +1,5 @@
 module BuildEval
-  module CIServer
+  module Server
 
     class Decorator
 
@@ -11,12 +11,12 @@ module BuildEval
         begin
           @delegate.build_result(name)
         rescue Exception
-          BuildEval::BuildResult.unknown(name)
+          BuildEval::Result::BuildResult.unknown(name)
         end
       end
 
       def monitor(*build_names)
-        BuildEval::Monitor.new(server: @delegate, build_names: build_names.flatten)
+        BuildEval::Monitor::Server.new(server: @delegate, build_names: build_names.flatten)
       end
 
     end

data/lib/build_eval/server/team_city.rb

@@ -0,0 +1,28 @@
+module BuildEval
+  module Server
+
+    class TeamCity
+
+      def initialize(args)
+        @base_uri = args[:uri]
+        @username = args[:username]
+        @password = args[:password]
+      end
+
+      def build_result(name)
+        response = BuildEval::Http.get(
+          "#{@base_uri}/httpAuth/app/rest/buildTypes/id:#{name}/builds", username: @username, password: @password
+        )
+        build_element = Nokogiri::XML(response.body).xpath("//build").first
+        raise "Unexpected build response: #{response.message}" unless build_element
+        BuildEval::Result::BuildResult.create(build_name: name, status_name: build_element.attribute("status").value)
+      end
+
+      def to_s
+        "TeamCity server #{@base_uri}"
+      end
+
+    end
+
+  end
+end

data/lib/build_eval/server/travis.rb

@@ -0,0 +1,26 @@
+module BuildEval
+  module Server
+
+    class Travis
+
+      def initialize(args)
+        @username = args[:username]
+      end
+
+      def build_result(name)
+        response = BuildEval::Http.get("https://api.travis-ci.org/repositories/#{@username}/#{name}/cc.xml")
+        build_element = Nokogiri::XML(response.body).xpath("//Project").first
+        raise "Unexpected build response: #{response.message}" unless build_element
+        BuildEval::Result::BuildResult.create(
+          build_name: name, status_name: build_element.attribute("lastBuildStatus").value
+        )
+      end
+
+      def to_s
+        "Travis CI #{@username}"
+      end
+
+    end
+
+  end
+end

data/lib/build_eval/version.rb

@@ -1,3 +1,3 @@
 module BuildEval
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.2".freeze
 end

data/lib/build_eval.rb

@@ -1,11 +1,16 @@
 require 'nokogiri'
 
-require_relative 'build_eval/status'
-require_relative 'build_eval/build_result'
-require_relative 'build_eval/build_results'
-require_relative 'build_eval/ci_server/decorator'
-require_relative 'build_eval/ci_server/team_city'
-require_relative 'build_eval/monitor'
+require_relative 'build_eval/http'
+require_relative 'build_eval/result/status'
+require_relative 'build_eval/result/build_result'
+require_relative 'build_eval/result/server_result'
+require_relative 'build_eval/result/composite_result'
+require_relative 'build_eval/server/decorator'
+require_relative 'build_eval/server/team_city'
+require_relative 'build_eval/server/travis'
+require_relative 'build_eval/monitor/base'
+require_relative 'build_eval/monitor/server'
+require_relative 'build_eval/monitor/composite'
 
 module BuildEval
 
@@ -14,14 +19,14 @@ module BuildEval
     def server(args)
       type_args = args.clone
       server_type = type_args.delete(:type)
-      BuildEval::CIServer::Decorator.new(server_class_for(server_type).new(type_args))
+      BuildEval::Server::Decorator.new(server_class_for(server_type).new(type_args))
     end
 
     private
 
     def server_class_for(type)
       begin
-        BuildEval::CIServer.const_get(type.to_s)
+        BuildEval::Server.const_get(type.to_s)
       rescue NameError
         raise "Server type '#{type}' is invalid"
       end

data/spec/lib/build_eval/http_spec.rb

@@ -0,0 +1,82 @@
+describe BuildEval::Http do
+
+  shared_examples_for "a http method returning a response" do
+
+    let(:response_status) { [ "200", "OK" ] }
+    let(:response_body)   { "Some Response Body" }
+
+    it "returns a response containing the response body" do
+      expect(subject.body).to eql(response_body)
+    end
+
+    it "returns a response containing the response status" do
+      expect(subject.code).to eql("200")
+    end
+
+    it "returns a response containing the response message" do
+      expect(subject.message).to eql("OK")
+    end
+
+  end
+
+  describe "::get" do
+
+    let(:scheme)     { "http" }
+    let(:host)       { "a.host" }
+    let(:path)       { "some/path" }
+    let(:uri_string) { "#{scheme}://#{host}/#{path}" }
+
+    subject { described_class.get(uri_string) }
+
+    context "when the uri is valid" do
+
+      let(:expected_request_uri) { uri_string }
+
+      before(:example) do
+        FakeWeb.register_uri(:get, expected_request_uri, status: response_status, body: response_body)
+      end
+
+      context "and the uri contains a http scheme" do
+
+        let(:scheme) { "http" }
+
+        it_behaves_like "a http method returning a response"
+
+      end
+
+      context "and the uri contains a https scheme" do
+
+        let(:scheme) { "https" }
+
+        it_behaves_like "a http method returning a response"
+
+      end
+
+      context "and basic authentication is provided" do
+
+        let(:username) { "some_username" }
+        let(:password) { "some_password" }
+
+        let(:expected_request_uri) { "#{scheme}://#{username}:#{password}@#{host}/#{path}" }
+
+        subject { described_class.get(uri_string, basic_authentication: { username: username, password: password }) }
+
+        it_behaves_like "a http method returning a response"
+
+      end
+
+    end
+
+    context "when the uri is invalid" do
+
+      before(:example) { FakeWeb.clean_registry }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(SocketError)
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,29 @@
+describe BuildEval::Monitor::Base do
+
+  class BuildEval::Monitor::TestableBase < BuildEval::Monitor::Base
+  end
+
+  let(:base_monitor) { BuildEval::Monitor::TestableBase.new }
+
+  describe "#+" do
+
+    let(:provided_monitor) { instance_double(BuildEval::Monitor::Base) }
+
+    subject { base_monitor + provided_monitor }
+
+    it "creates a composite monitor combining the monitor with the provided monitor" do
+      expect(BuildEval::Monitor::Composite).to receive(:new).with(base_monitor, provided_monitor)
+
+      subject
+    end
+
+    it "returns the composite monitor" do
+      composite_monitor = instance_double(BuildEval::Monitor::Composite)
+      allow(BuildEval::Monitor::Composite).to receive(:new).and_return(composite_monitor)
+
+      expect(subject).to eql(composite_monitor)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,38 @@
+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") } }
+
+    subject { composite.evaluate }
+
+    before(:example) do
+      monitors.zip(results) { |monitor, result| allow(monitor).to receive(:evaluate).and_return(result) }
+    end
+
+    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
+      expect(BuildEval::Result::CompositeResult).to receive(:new).with(results)
+
+      subject
+    end
+
+    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

@@ -0,0 +1,43 @@
+describe BuildEval::Monitor::Server do
+
+  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
+
+    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
+      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
+      expect(BuildEval::Result::ServerResult).to receive(:new).with(server, anything)
+
+      subject
+    end
+
+    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
+      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/{build_result_spec.rb → result/build_result_spec.rb}

@@ -1,4 +1,4 @@
-describe BuildEval::BuildResult do
+describe BuildEval::Result::BuildResult do
 
   describe "::create" do
 
@@ -13,14 +13,14 @@ describe BuildEval::BuildResult do
     end
 
     it "determines the status with the provided status name" do
-      expect(BuildEval::Status).to receive(:find).with(status_name)
+      expect(BuildEval::Result::Status).to receive(:find).with(status_name)
 
       subject
     end
 
     it "returns a result with the determined status" do
-      status = BuildEval::Status::UNKNOWN
-      allow(BuildEval::Status).to receive(:find).and_return(status)
+      status = BuildEval::Result::Status::UNKNOWN
+      allow(BuildEval::Result::Status).to receive(:find).and_return(status)
 
       expect(subject.status).to eql(status)
     end
@@ -38,19 +38,19 @@ describe BuildEval::BuildResult do
     end
 
     it "returns a result with an unknown status" do
-      expect(subject.status).to eql(BuildEval::Status::UNKNOWN)
+      expect(subject.status).to eql(BuildEval::Result::Status::UNKNOWN)
     end
 
   end
 
   describe "#unsuccessful?" do
 
-    let(:status)       { instance_double(BuildEval::Status) }
+    let(:status)       { instance_double(BuildEval::Result::Status) }
     let(:build_result) { described_class.create(build_name: "some build", status_name: "some status") }
 
     subject { build_result.unsuccessful? }
 
-    before(:example) { allow(BuildEval::Status).to receive(:find).and_return(status) }
+    before(:example) { allow(BuildEval::Result::Status).to receive(:find).and_return(status) }
 
     it "delegates to the underlying status" do
       allow(status).to receive(:unsuccessful?).and_return(true)
@@ -64,13 +64,13 @@ describe BuildEval::BuildResult do
 
     let(:build_name)                   { "Some build name" }
     let(:status_string_representation) { "SUCCESS" }
-    let(:status)                       { instance_double(BuildEval::Status, to_s: status_string_representation) }
+    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") }
 
     subject { build_result.to_s }
 
-    before(:example) { allow(BuildEval::Status).to receive(:find).and_return(status) }
+    before(:example) { allow(BuildEval::Result::Status).to receive(:find).and_return(status) }
 
     it "contains the name of the build" do
       expect(subject).to include(build_name)