kalibro_client 3.0.1 → 4.0.0.alpha1

data/lib/kalibro_client/entities/configurations/reading_group.rb

@@ -5,7 +5,7 @@
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ -25,10 +25,6 @@ module KalibroClient
           @id = value.to_i
         end
 
-        def self.all
-          create_objects_array_from_hash(request('', {}, :get))
-        end
-
         def readings
           KalibroClient::Entities::Configurations::Reading.create_objects_array_from_hash(self.class.request(':id/readings', {id: @id}, :get))
         end

data/lib/kalibro_client/entities/miscellaneous/base.rb

@@ -1,12 +1,14 @@
+require 'likeno/helpers/hash_converters'
+
 module KalibroClient
   module Entities
     module Miscellaneous
       class Base
         def initialize(attributes={})
-          attributes.each { |field, value| send("#{field}=", value) if self.class.is_valid?(field) }
+          attributes.each { |field, value| send("#{field}=", value) if self.class.valid?(field) }
         end
 
-        include HashConverters
+        include Likeno::HashConverters
         def to_hash(options={})
           hash = Hash.new
           excepts = options[:except].nil? ? [] : options[:except]

data/lib/kalibro_client/entities/miscellaneous/metric.rb

@@ -1,5 +1,3 @@
-require 'kalibro_client/helpers/hash_converters'
-
 module KalibroClient
   module Entities
     module Miscellaneous

data/lib/kalibro_client/entities/processor/base.rb

@@ -1,14 +1,14 @@
 require 'json'
-require 'kalibro_client/helpers/date_attributes'
+require 'likeno/helpers/date_attributes'
 
 module KalibroClient
   module Entities
     module Processor
       class Base < KalibroClient::Entities::Base
-        include DateAttributes
+        include Likeno::DateAttributes
 
         def self.address
-          :processor_address
+          Likeno.config[:processor_address]
         end
       end
     end

data/lib/kalibro_client/entities/processor/hotspot_metric_result.rb

@@ -24,7 +24,7 @@ module KalibroClient
         def initialize(attributes={}, persisted=false)
           @line_number = attributes["line_number"].to_i
           attributes.each do |field, value|
-            if field != "line_number" and self.class.is_valid?(field)
+            if field != "line_number" and self.class.valid?(field)
               send("#{field}=", value)
             end
           end

data/lib/kalibro_client/entities/processor/metric_collector_details.rb

@@ -36,24 +36,36 @@ module KalibroClient
           metric.nil? ? nil : metric.last
         end
 
+        def find_metric_by_name!(name)
+          metric = self.find_metric_by_name(name)
+          raise Likeno::Errors::RecordNotFound if metric.nil?
+          metric
+        end
+
         def find_metric_by_code(metric_code)
           @supported_metrics[metric_code]
         end
 
+        def find_metric_by_code!(metric_code)
+          metric = self.find_metric_by_code(metric_code)
+          raise Likeno::Errors::RecordNotFound if metric.nil?
+          metric
+        end
+
         def self.find_by_name(metric_collector_name)
           begin
-            new request(:find, {name: metric_collector_name})["metric_collector_details"]
-          rescue
-            raise KalibroClient::Errors::RecordNotFound
+            self.find_by_name!(metric_collector_name)
+          rescue Likeno::Errors::RecordNotFound
+            nil
           end
         end
 
-        def self.all_names
-          request(:names, {}, :get)['metric_collector_names'].to_a
+        def self.find_by_name!(metric_collector_name)
+          new request(:find, {name: metric_collector_name})["metric_collector_details"]
         end
 
-        def self.all
-          create_objects_array_from_hash(request('', {}, :get))
+        def self.all_names
+          request(:names, {}, :get)['metric_collector_names'].to_a
         end
       end
     end

data/lib/kalibro_client/entities/processor/module_result.rb

@@ -89,19 +89,6 @@ module KalibroClient
           HotspotMetricResult.create_objects_array_from_hash(self.class.request(":id/hotspot_metric_results",
                                                                                 {id: self.id}, :get))
         end
-
-        # FIXME: KalibroProcessor should return a 404 if the object does not exist instead of 422
-        def self.find(id)
-          begin
-            super
-          rescue KalibroClient::Errors::RequestError => e
-            if(e.response.status == 422)
-              raise KalibroClient::Errors::RecordNotFound.new(response: e.response)
-            else
-              raise e
-            end
-          end
-        end
       end
     end
   end

data/lib/kalibro_client/entities/processor/project.rb

@@ -25,10 +25,6 @@ module KalibroClient
           @id = value.to_i
         end
 
-        def self.all
-          create_objects_array_from_hash(request('', {}, :get))
-        end
-
         def repositories
           Repository.create_objects_array_from_hash(self.class.request(':id/repositories', {id: id}, :get))
         end

data/lib/kalibro_client/entities/processor/repository.rb

@@ -112,10 +112,6 @@ module KalibroClient
           Processing.new(self.class.request("#{self.id}/last_processing/before", {:date => date})['processing'])
         end
 
-        def self.all
-          create_objects_array_from_hash(request("", {}, :get))
-        end
-
         def self.branches(url, scm_type)
           request("/branches", {url: url, scm_type: scm_type})
         end

data/lib/kalibro_client/entities/processor/tree_metric_result.rb

@@ -24,7 +24,7 @@ module KalibroClient
           value = attributes["value"]
           @value = (value == "NaN") ? attributes["aggregated_value"].to_f : value.to_f
           attributes.each do |field, value|
-            if field!= "value" and field!= "aggregated_value" and self.class.is_valid?(field)
+            if field!= "value" and field!= "aggregated_value" and self.class.valid?(field)
               send("#{field}=", value)
             end
           end

data/lib/kalibro_client/errors.rb

@@ -14,7 +14,4 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-require 'kalibro_client/errors/standard'
-require 'kalibro_client/errors/request_error'
-require 'kalibro_client/errors/record_not_found'
-require 'kalibro_client/errors/record_invalid'
+require 'likeno/errors'

data/lib/kalibro_client/kalibro_cucumber_helpers.rb

@@ -14,47 +14,18 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-require 'yaml'
-require 'kalibro_client/kalibro_cucumber_helpers/configuration'
+require 'kalibro_client/kalibro_cucumber_helpers/cleaner'
 
 module KalibroClient
   module KalibroCucumberHelpers
-    @configuration = KalibroClient::KalibroCucumberHelpers::Configuration.new
-
-    def KalibroCucumberHelpers.configure(&config_block)
-      config_block.call(@configuration)
-    end
-
-    def KalibroCucumberHelpers.configure_from_yml(file_path)
-      configuration = YAML.load(File.open("features/support/kalibro_cucumber_helpers.yml"))
-
-      configuration["kalibro_cucumber_helpers"].each do |config, value|
-        @configuration.send("#{config}=", value)
-      end
-    end
-
-    def KalibroCucumberHelpers.configuration
-      @configuration
+    def self.clean_processor
+      @processor_cleaner ||= KalibroClient::KalibroCucumberHelpers::Cleaner.new(:processor_address)
+      @processor_cleaner.clean_database
     end
 
-    def KalibroCucumberHelpers.clean_processor
-      client = Faraday.new(:url => @configuration.kalibro_processor_address) do |conn|
-        conn.request :json
-        conn.response :json, :content_type => /\bjson$/
-        conn.adapter  Faraday.default_adapter  # make requests with Net::HTTP
-      end
-
-      client.send(:post, "/tests/clean_database", {})
-    end
-
-    def KalibroCucumberHelpers.clean_configurations
-      client = Faraday.new(:url => @configuration.kalibro_configurations_address) do |conn|
-        conn.request :json
-        conn.response :json, :content_type => /\bjson$/
-        conn.adapter  Faraday.default_adapter  # make requests with Net::HTTP
-      end
-
-      client.send(:post, "/tests/clean_database", {})
+    def self.clean_configurations
+      @configurations_cleaner ||= KalibroClient::KalibroCucumberHelpers::Cleaner.new(:configurations_address)
+      @configurations_cleaner.clean_database
     end
   end
 end

data/lib/kalibro_client/kalibro_cucumber_helpers/cleaner.rb

@@ -0,0 +1,27 @@
+require 'likeno'
+
+module KalibroClient
+  module KalibroCucumberHelpers
+    class Cleaner
+      include Likeno::RequestMethods
+
+      attr_reader :address_key
+
+      def initialize(address_key)
+        @address_key = address_key
+      end
+
+      def address
+        Likeno.config[address_key]
+      end
+
+      def endpoint
+        'tests'
+      end
+
+      def clean_database
+        request('clean_database', {}, :post)
+      end
+    end
+  end
+end

data/lib/kalibro_client/version.rb

@@ -15,5 +15,5 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 module KalibroClient
-  VERSION = "3.0.1"
+  VERSION = "4.0.0.alpha1"
 end

data/spec/entities/base_spec.rb

@@ -19,467 +19,35 @@ require 'spec_helper'
 # Create a class that has the attribute assignment methods, since some methods expect they exist
 # (and usually the subclasses do that).
 
+class MiscellaneousTest < KalibroClient::Entities::Miscellaneous::Base
+  attr_accessor :id
+end
+
 class BaseTest < KalibroClient::Entities::Base
-  attr_accessor :id, :created_at, :updated_at
+  attr_accessor :id, :miscellaneous
 end
 
 describe KalibroClient::Entities::Base do
   subject { BaseTest.new }
 
-  describe 'new' do
-    subject { described_class.new({}) }
-
-    it 'is expected to create a model from an empty hash' do
-      expect(subject.kalibro_errors).to eq([])
-    end
-  end
-
-  describe 'entity_name' do
-    it 'is expected to be a String' do
-      expect(subject.class.entity_name).to be_a(String)
-    end
-
-    it 'is expected to return Base' do
-      expect(subject.class.entity_name).to eq('base')
-    end
-  end
-
-  describe 'endpoint' do
-    it 'is expected to return the entity_name' do
-      endpoint = 'tests'
-      described_class.expects(:entity_name).returns(endpoint)
-      expect(described_class.endpoint).to eq(endpoint)
-    end
-  end
-
-  describe 'client' do
-    it 'returns a Faraday::Connection' do
-      expect { described_class.client }.to raise_error(NotImplementedError)
-    end
-  end
-
-  describe 'request' do
-    context 'with successful responses' do
-      let(:exists_response) { { 'exists' => false } }
-      let(:bases_response) { { 'bases' => { 'id' => 1 } } }
-      let(:prefix_bases_response) { { 'bases' => { 'id' => 2 } } }
-      let(:faraday_stubs) { Faraday::Adapter::Test::Stubs.new }
-      let(:connection) { Faraday.new { |builder| builder.adapter :test, faraday_stubs } }
-
-      before :each do
-        subject.class.expects(:client).at_least_once.returns(connection)
-        subject.class.expects(:endpoint).at_least_once.returns('bases')
-      end
-
-      after :each do
-        faraday_stubs.verify_stubbed_calls
-      end
-
-      context 'without an id parameter' do
-        context 'without a prefix' do
-          it 'is expected to make the request without the prefix' do
-            # stub.get receives arguments: path, headers, block
-            # The block should be a Array [status, headers, body]
-            faraday_stubs.get('/bases/') { [200, {}, bases_response] }
-            response = subject.class.request('', {}, :get)
-            expect(response).to eq(bases_response)
-          end
-        end
-
-        context 'with a prefix' do
-          it 'is expected to make the request with the prefix' do
-            # stub.get receives arguments: path, headers, block
-            # The block should be a Array [status, headers, body]
-            faraday_stubs.get('/prefix/bases/') { [200, {}, prefix_bases_response] }
-            response = subject.class.request('', {}, :get, 'prefix')
-            expect(response).to eq(prefix_bases_response)
-          end
-        end
-      end
-
-      context 'with an id parameter' do
-        it 'is expected to make the request with the id included' do
-          # stub.get receives arguments: path, headers, block
-          # The block should be a Array [status, headers, body]
-          faraday_stubs.get('/bases/1/exists') { [200, {}, exists_response] }
-          response = subject.class.request(':id/exists', { id: 1 }, :get)
-          expect(response).to eq(exists_response)
-        end
-      end
-    end
-
-    context 'when the record was not found' do
-      context 'and or the status is 404' do
-        let!(:faraday_stubs) do
-          Faraday::Adapter::Test::Stubs.new do |stub|
-            # stub.get receives arguments: path, headers, block
-            # The block should be a Array [status, headers, body]
-            stub.get('/bases/1') { [404, {}, {}] }
-          end
-        end
-        let!(:connection) { Faraday.new { |builder| builder.adapter :test, faraday_stubs } }
-
-        before :each do
-          described_class.expects(:client).at_least_once.returns(connection)
-        end
-
-        it 'is expected to raise a RecordNotFound error' do
-          expect { described_class.request(':id', { id: 1 }, :get) }.to raise_error(KalibroClient::Errors::RecordNotFound)
-          faraday_stubs.verify_stubbed_calls
-        end
-      end
-
-      context 'and or the response has a NotFound error message' do
-        let!(:faraday_stubs) do
-          Faraday::Adapter::Test::Stubs.new do |stub|
-            # stub.get receives arguments: path, headers, block
-            # The block should be a Array [status, headers, body]
-            stub.get('/bases/1') { [422, {}, { 'errors' => 'RecordNotFound' }] }
-          end
-        end
-        let!(:connection) { Faraday.new { |builder| builder.adapter :test, faraday_stubs } }
-
-        before :each do
-          described_class.expects(:client).at_least_once.returns(connection)
-        end
-
-        it 'is expected to raise a RecordNotFound error' do
-          expect { described_class.request(':id', { id: 1 }, :get) }.to raise_error(KalibroClient::Errors::RecordNotFound)
-          faraday_stubs.verify_stubbed_calls
-        end
-      end
-    end
-
-    context 'with an unsuccessful request' do
-      let!(:stubs) { Faraday::Adapter::Test::Stubs.new { |stub| stub.get('/bases/1/exists') { [500, {}, {}] } } }
-      let(:connection) { Faraday.new { |builder| builder.adapter :test, stubs } }
-
-      before :each do
-        subject.class.expects(:client).at_least_once.returns(connection)
-      end
-
-      it 'is expected to raise a RequestError with the response' do
-        expect { subject.class.request(':id/exists', { id: 1 }, :get) }.to raise_error do |error|
-          expect(error).to be_a(KalibroClient::Errors::RequestError)
-          expect(error.response.status).to eq(500)
-          expect(error.response.body).to eq({})
-        end
-        stubs.verify_stubbed_calls
-      end
-    end
-  end
-
-  describe 'to_hash' do
-    it 'is expected to return an empty hash' do
-      expect(subject.to_hash).to be_empty
-    end
+  before do
+    subject.id = 24
+    subject.miscellaneous = MiscellaneousTest.new
+    subject.miscellaneous.id = 42
   end
 
-  describe 'to_object' do
-    it 'is expected to return an Object with an empty hash' do
-      expect(described_class.to_object({})).to eq(FactoryGirl.build(:model))
-    end
-
-    it "is expected to remain an object if it isn't a Hash" do
-      expect(described_class.to_object(Object.new)).to be_an(Object)
-    end
-  end
-
-  describe 'to_objects_array' do
-    it 'is expected to convert [{}] to [Model]' do
-      expect(described_class.to_objects_array({})).to eq([FactoryGirl.build(:model)])
-    end
-
-    it 'is expected to remain an array if it already is one' do
-      object = Object.new
-      expect(described_class.to_objects_array([object])).to eq([object])
-    end
-  end
-
-  shared_examples 'persistence method' do |method_name, http_method, has_id = true|
-    before :each do
-      subject.id = 42 if has_id
-    end
-
-    let(:url) { has_id ? ':id' : '' }
-    let(:params) { has_id ? has_entry(id: 42) : anything }
-
-    context 'when a record does not exist with given id' do
-      before :each do
-        subject.class.expects(:request).with(url, params, http_method, '').
-          raises(KalibroClient::Errors::RecordNotFound)
-      end
-
-      it 'is expected to raise a RecordNotFound error' do
-        expect { subject.send(method_name) }.to raise_error(KalibroClient::Errors::RecordNotFound)
-      end
-    end
-
-    context 'when a server error is returned' do
-      before :each do
-        error = KalibroClient::Errors::RequestError.new(response: mock(status: 500))
-
-        subject.class.expects(:request).with(url, params, http_method, '').raises(error)
-      end
-
-      it 'is expected to raise a RequestError error' do
-        expect { subject.send(method_name) }.to raise_error(KalibroClient::Errors::RequestError)
-      end
-    end
-
-    context 'when a regular kind of error is returned' do
-      before :each do
-        error = KalibroClient::Errors::RequestError.new(response: mock(status: 422, body: { 'errors' => errors }))
-
-        subject.class.expects(:request).with(url, params, http_method, '').raises(error)
-      end
-
-      context 'with a single error' do
-        let(:errors) { "error" }
-
-        it 'is expected to set the kalibro_errors field' do
-          expect(subject.send(method_name)).to eq(false)
-          expect(subject.kalibro_errors).to eq([errors])
-        end
-      end
-
-      context 'with an array of errors' do
-        let(:errors) { ["error_1", "error_2"] }
-
-        it 'is expected to set the kalibro_errors field' do
-          expect(subject.send(method_name)).to eq(false)
-          expect(subject.kalibro_errors).to eq(errors)
-        end
-      end
-
-      context 'with no error message at all' do
-        let(:errors) { nil }
-
-        it 'is expected to set the kalibro_errors field' do
-          expect(subject.send(method_name)).to eq(false)
-          expect(subject.kalibro_errors.first).to be_a(KalibroClient::Errors::RequestError)
-        end
+  describe 'class method' do
+    describe 'module_name' do
+      it 'is expected to return the camelized gem name' do
+        expect(described_class.module_name).to eq('KalibroClient')
       end
     end
   end
 
-  describe 'save' do
-    it_behaves_like 'persistence method', :save, :post, false # false means Don't use ids in URLs
-
-    context 'with a successful response' do
-      context 'when it is not persisted' do
-        before :each do
-          subject.class.expects(:request).at_least_once.with('', anything, :post, '').
-            returns({ "base" => { 'id' => 42, 'errors' => [] } })
-        end
-
-        it 'is expected to make a request to save model with id and return true without errors' do
-          expect(subject.save).to be(true)
-          expect(subject.id).to eq(42)
-          expect(subject.kalibro_errors).to be_empty
-        end
-      end
-
-      context 'when it is persisted' do
-        before :each do
-          subject.expects(:persisted?).at_least_once.returns(true)
-        end
-
-        it 'is expected to call the update method' do
-          subject.expects(:update).returns(true)
-          expect(subject.save).to eq(true)
-        end
-      end
-    end
-  end
-
-  describe 'update' do
-    it_behaves_like 'persistence method', :update, :put
-
-    context 'with valid parameters' do
-      before :each do
-        id = 42
-
-        subject.expects(:id).at_least_once.returns(id)
-        described_class.expects(:request).with(':id', has_entry(id: id), :put, '').
-          returns({ "base" => { 'id' => id, 'errors' => [] }})
-      end
-
-      it 'is expected to return true' do
-        expect(subject.update).to eq(true)
-      end
-    end
-  end
-
-  describe 'create' do
-    before :each do
-      subject.expects(:save)
-      described_class.
-        expects(:new).
-        with({}).
-        returns(subject)
-    end
-
-    it 'is expected to instantiate and save the model' do
-      expect(described_class.create {}).to eq(subject)
-    end
-  end
-
-  describe 'find' do
-    context 'with an inexistent id' do
-      before :each do
-        subject.class.expects(:request).at_least_once.with(':id', has_entry(id: 0), :get).
-          raises(KalibroClient::Errors::RecordNotFound)
-      end
-
-      it 'is expected to raise a RecordNotFound error' do
-        expect { subject.class.find(0) }.to raise_error(KalibroClient::Errors::RecordNotFound)
-      end
-    end
-
-    context 'with an existent id' do
-      before :each do
-        subject.class.expects(:request).with(':id', has_entry(id: 42), :get).
-          returns("base" => { 'id' => 42 })
-      end
-
-      it 'is expected to return an empty model' do
-        expect(subject.class.find(42).id).to eq(42)
-      end
-    end
-  end
-
-  describe 'destroy' do
-    it_behaves_like 'persistence method', :destroy, :delete
-
-    context 'when it gets successfully destroyed' do
-      before :each do
-        subject.expects(:id).at_least_once.returns(42)
-        described_class.expects(:request).with(':id', { id: subject.id }, :delete, '').returns({})
-      end
-
-      it 'is expected to remain with the errors array empty and not persisted' do
-        subject.destroy
-        expect(subject.kalibro_errors).to be_empty
-        expect(subject.persisted?).to eq(false)
-      end
-    end
-  end
-
-  describe 'save!' do
-    it 'is expected to call save and not raise when saving works' do
-      subject.expects(:save).returns(true)
-      expect { subject.save! }.not_to raise_error
-    end
-
-    it 'is expected to call save and raise RecordInvalid when saving fails' do
-      subject.expects(:kalibro_errors).returns(['test1', 'test2'])
-      subject.expects(:save).returns(false)
-
-      expect { subject.save! }.to raise_error { |error|
-        expect(error).to be_a(KalibroClient::Errors::RecordInvalid)
-        expect(error.record).to be(subject)
-        expect(error.message).to eq('Record invalid: test1, test2')
-      }
-    end
-  end
-
-  describe '==' do
-    subject { FactoryGirl.build(:model) }
-
-    context 'comparing objects from different classes' do
-      it 'is expected to return false' do
-        expect(subject).not_to eq(Object.new)
-      end
-    end
-
-    context 'with two models with different attribute values' do
-      let(:another_model) { FactoryGirl.build(:model) }
-
-      before :each do
-        subject.expects(:variable_names).returns(["answer"])
-        subject.expects(:send).with("answer").returns(42)
-        another_model.expects(:send).with("answer").returns(41)
-      end
-
-      it 'is expected to return false' do
-        expect(subject).not_to eq(another_model)
-      end
-    end
-
-    context 'with two empty models' do
-      it 'is expected to return true' do
-        expect(subject).to eq(FactoryGirl.build(:model))
-      end
-    end
-  end
-
-  describe 'exists?' do
-    context 'with an inexistent id' do
-      before :each do
-        described_class.
-          expects(:request).
-          with(':id/exists', { id: 0 }, :get).
-          returns({ 'exists' => false })
-      end
-
-      it 'is expected to return false' do
-        expect(described_class.exists?(0)).to eq(false)
-      end
-    end
-
-    context 'with an existent id' do
-      before :each do
-        described_class.
-          expects(:request).
-          with(':id/exists', { id: 42 }, :get).
-          returns({ 'exists' => true })
-      end
-
-      it 'is expected to return false' do
-        expect(described_class.exists?(42)).to eq(true)
-      end
-    end
-  end
-
-  describe 'create_objects_array_from_hash' do
-    subject { FactoryGirl.build(:model) }
-
-    context 'with nil' do
-      it 'is expected to return an empty array' do
-        expect(described_class.create_objects_array_from_hash("bases" => [])).to eq([])
-      end
-    end
-
-    context 'with a Hash' do
-      it 'is expected to return the correspondent object to the given hash inside of an Array' do
-        expect(described_class.create_objects_array_from_hash("bases" => {})).to eq([subject])
-      end
-    end
-  end
-
-  describe 'is_valid?' do
-    context 'with a global var' do
-      it 'is expected to return false' do
-        expect(described_class.is_valid?('@test')).to be_falsey
-      end
-    end
-
-    context 'with the attributes var' do
-      it 'is expected to return false' do
-        expect(described_class.is_valid?(:attributes!)).to be_falsey
-      end
-    end
-
-    context 'with a xsi var' do
-      it 'is expected to return false' do
-        expect(described_class.is_valid?('test_xsi')).to be_falsey
-      end
-    end
-
-    context 'with a valid var' do
-      it 'is expected to return true' do
-        expect(described_class.is_valid?('test')).to be_truthy
+  describe 'instance method' do
+    describe 'convert_to_hash' do
+      it 'is expected to convert miscellaneous nested objects' do
+        expect(subject.to_hash).to eq({'id' => "24", 'miscellaneous' => {'id' => "42"}})
       end
     end
   end