kalibro_client 0.0.1 → 0.0.2

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 = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/entities/base_spec.rb

@@ -104,37 +104,105 @@ describe KalibroClient::Entities::Base do
 
   describe 'to_objects_array' do
     it 'should convert [{}] to [Model]' do
-      expect(KalibroClient::Entities::Base.to_objects_array({})).to eq([FactoryGirl.build(:model)]) 
+      expect(KalibroClient::Entities::Base.to_objects_array({})).to eq([FactoryGirl.build(:model)])
     end
 
     it 'should remain an array if it already is one' do
       object = Object.new
-      expect(KalibroClient::Entities::Base.to_objects_array([object])).to eq([object]) 
+      expect(KalibroClient::Entities::Base.to_objects_array([object])).to eq([object])
     end
   end
 
   describe 'save' do
-    before :each do
-      KalibroClient::Entities::Base.
-        expects(:request).
-        with('', {base: {}}, :post, '').returns({"base" => {'id' => 42, 'kalibro_errors' => []}})
+    context "when it is not persisted" do
+      context "when it doesn't have the method id=" do
+        before :each do
+          KalibroClient::Entities::Base.
+            expects(:request).
+            with('', {base: {}}, :post, '').returns({"base" => {'id' => 42, 'kalibro_errors' => []}})
+        end
+
+        it 'should make a request to save model with id returning false and an error' do
+          expect(subject.save).to be(false)
+          expect(subject.kalibro_errors[0]).to be_a(NoMethodError)
+        end
+      end
+
+      context 'when it has the method id=' do
+        before :each do
+          KalibroClient::Entities::Base.
+            expects(:request).
+            with('', {base: {}}, :post, '').returns({"base" => {'id' => 42, 'kalibro_errors' => []}})
+          KalibroClient::Entities::Base.any_instance.expects(:id=).with(42).returns(42)
+        end
+
+        it 'should make a request to save model with id and return true without errors' do
+          expect(subject.save).to be(true)
+          expect(subject.kalibro_errors).to be_empty
+        end
+      end
+
+      context "when it returns with a kalibro processor error" do
+        before :each do
+          KalibroClient::Entities::Base.
+            expects(:request).
+            with('', {base: {}}, :post, '').returns({"errors" => ["Name has already been taken"]})
+        end
+
+        it 'should make a request to save model returning false and a kalibro error' do
+          expect(subject.save).to be(false)
+          expect(subject.kalibro_errors[0]).to eq("Name has already been taken")
+        end
+      end
     end
 
-    context "when it doesn't have the method id=" do
-      it 'should make a request to save model with id returning false and an error' do
-        expect(subject.save).to be(false)
-        expect(subject.kalibro_errors[0]).to be_a(NoMethodError)
+    context 'when it is persisted' do
+      before :each do
+        subject.persisted = true
+      end
+
+      it 'is expected to call the update method'  do
+        subject.expects(:update)
+
+        subject.save
       end
     end
+  end
 
-    context 'when it has the method id=' do
+  describe 'update' do
+    let!(:id) { 42 }
+
+    context 'with valid parameters' do
       before :each do
-        KalibroClient::Entities::Base.any_instance.expects(:id=).with(42).returns(42)
+        KalibroClient::Entities::Base.
+              expects(:request).
+              with(':id', {base: {}, id: id}, :put, '').returns({"base" => {'id' => id, 'kalibro_errors' => []}})
+        subject.expects(:id).returns(id)
+        subject.expects(:to_hash).returns({})
       end
 
-      it 'should make a request to save model with id and return true without errors' do
-        expect(subject.save).to be(true)
-        expect(subject.kalibro_errors).to be_empty
+      it 'is expect to return true' do
+        expect(subject.update).to be_truthy
+      end
+    end
+
+    context 'with invalid parameters' do
+      before :each do
+        KalibroClient::Entities::Base.
+              expects(:request).
+              with(':id', {base: {}, id: id}, :put, '').returns({"errors" => ["Error"]})
+        subject.expects(:id).returns(id)
+        subject.expects(:to_hash).returns({})
+      end
+
+      it 'is expect to return false' do
+        expect(subject.update).to be_falsey
+      end
+
+      it 'is expect fill the errors' do
+        subject.update
+
+        expect(subject.kalibro_errors).to_not be_empty
       end
     end
   end
@@ -175,7 +243,7 @@ describe KalibroClient::Entities::Base do
         subject.expects(:variable_names).returns(["answer"])
         subject.expects(:send).with("answer").returns(42)
         another_model.expects(:send).with("answer").returns(41)
-      end 
+      end
 
       it 'should return false' do
         expect(subject).not_to eq(another_model)
@@ -248,25 +316,39 @@ describe KalibroClient::Entities::Base do
     context 'when it gets successfully destroyed' do
       before :each do
         subject.expects(:id).at_least_once.returns(42)
-        KalibroClient::Entities::Base.expects(:request).with(':id',{id: subject.id}, :delete, '')
+        KalibroClient::Entities::Base.expects(:request).with(':id',{id: subject.id}, :delete, '').returns({})
       end
 
-      it 'should remain with the errors array empty' do
+      it 'should remain with the errors array empty and not persisted' do
         subject.destroy
         expect(subject.kalibro_errors).to be_empty
+        expect(subject.persisted?).to be_falsey
       end
     end
 
     context 'when the destruction fails' do
-      before :each do
-        subject.expects(:id).at_least_once.returns(42)
-        KalibroClient::Entities::Base.expects(:request).with(':id',{id: subject.id}, :delete, '').raises(Exception.new)
+      context 'raising a exception' do
+        before :each do
+          subject.expects(:id).at_least_once.returns(42)
+          KalibroClient::Entities::Base.expects(:request).with(':id',{id: subject.id}, :delete, '').raises(Exception.new)
+        end
+
+        it "should have an exception inside it's errors" do
+          subject.destroy
+
+          expect(subject.kalibro_errors[0]).to be_an(Exception)
+        end
       end
 
-      it "should have an exception inside it's errors" do
-        subject.destroy
+      context 'returning kalibro_errors' do
+        before :each do
+          subject.expects(:id).at_least_once.returns(42)
+          KalibroClient::Entities::Base.expects(:request).with(':id',{id: subject.id}, :delete, '').returns({'errors' => ['Error']})
+        end
 
-        expect(subject.kalibro_errors[0]).to be_an(Exception)
+        it 'is expected to return false' do
+          expect(subject.destroy).to be_falsey
+        end
       end
     end
   end

data/spec/entities/configurations/kalibro_configuration_spec.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
@@ -39,22 +39,22 @@ describe KalibroClient::Entities::Configurations::KalibroConfiguration do
     end
 
     context 'with many configurations' do
-      let(:configuration) { FactoryGirl.build(:configuration_with_id) }
-      let(:another_configuration) { FactoryGirl.build(:another_configuration) }
+      let(:kalibro_configuration) { FactoryGirl.build(:kalibro_configuration_with_id) }
+      let(:another_kalibro_configuration) { FactoryGirl.build(:another_kalibro_configuration) }
 
       before :each do
         KalibroClient::Entities::Configurations::KalibroConfiguration.
           expects(:request).
           with('', {}, :get).
-          returns({'kalibro_configurations' => [configuration.to_hash, another_configuration.to_hash]})
+          returns({'kalibro_configurations' => [kalibro_configuration.to_hash, another_kalibro_configuration.to_hash]})
       end
 
       it 'should return the two elements' do
-        configurations = KalibroClient::Entities::Configurations::KalibroConfiguration.all
+        kalibro_configurations = KalibroClient::Entities::Configurations::KalibroConfiguration.all
 
-        expect(configurations.size).to eq(2)
-        expect(configurations.first.name).to eq(configuration.name)
-        expect(configurations.last.name).to eq(another_configuration.name)
+        expect(kalibro_configurations.size).to eq(2)
+        expect(kalibro_configurations.first.name).to eq(kalibro_configuration.name)
+        expect(kalibro_configurations.last.name).to eq(another_kalibro_configuration.name)
       end
     end
   end

data/spec/entities/configurations/kalibro_range_spec.rb

@@ -33,30 +33,6 @@ describe KalibroClient::Entities::Configurations::KalibroRange do
     end
   end
 
-  describe 'beginning=' do
-    it 'should set the value of the attribute as a float' do
-      subject.beginning = "12.3"
-      expect(subject.beginning).to eq(12.3)
-    end
-
-    it 'should set beginning to infinity' do
-      subject.beginning = "-INF"
-      expect(subject.beginning).to eq("-INF")
-    end
-  end
-
-  describe 'end=' do
-    it 'should set the value of the attribute as a float' do
-      subject.end = "23.4"
-      expect(subject.end).to eq(23.4)
-    end
-
-    it 'should set end to infinity' do
-      subject.end = "INF"
-      expect(subject.end).to eq("INF")
-    end
-  end
-
   describe 'getting reading attribute' do
     let(:reading) { FactoryGirl.build(:reading_with_id) }
 
@@ -171,4 +147,22 @@ describe KalibroClient::Entities::Configurations::KalibroRange do
       subject.destroy
     end
   end
+
+  # The only purpose of this test is to cover the overrided update_params method
+  describe 'update' do
+    subject {FactoryGirl.build(:range_with_id)}
+
+    before :each do
+      subject.end = "555"
+      KalibroClient::Entities::Configurations::KalibroRange.
+        expects(:request).
+        with(':id', {:kalibro_range => subject.to_hash, :id => subject.id}, :put, "metric_configurations/#{subject.metric_configuration_id}").
+        returns("errors" => nil)
+    end
+
+    it 'should make a request to updatethe model and return true without errors' do
+      expect(subject.update).to be(true)
+      expect(subject.kalibro_errors).to be_empty
+    end
+  end
 end

data/spec/entities/configurations/metric_configuration_spec.rb

@@ -34,22 +34,6 @@ describe KalibroClient::Entities::Configurations::MetricConfiguration do
   describe 'metric=' do
 
     context 'with a Hash' do
-      context 'Metric' do
-        let!(:metric) { FactoryGirl.build(:metric) }
-
-        before :each do
-          KalibroClient::Entities::Miscellaneous::Metric.
-          expects(:to_object).at_least_once.
-          with(metric.to_hash).
-          returns(metric)
-        end
-
-        it 'should convert the argument and set the metric' do
-          subject.metric = metric.to_hash
-          expect(subject.metric).to eq(metric)
-        end
-      end
-
       context 'NativeMetric' do
         let!(:metric) { FactoryGirl.build(:loc) }
 
@@ -130,23 +114,23 @@ describe KalibroClient::Entities::Configurations::MetricConfiguration do
     subject {FactoryGirl.build(:metric_configuration_with_id)}
 
     it 'should not include the configuration_id' do
-      expect(subject.to_hash[:configuration_id]).to be_nil
+      expect(subject.to_hash[:kalibro_configuration_id]).to be_nil
     end
   end
 
   describe 'metric_configurations_of' do
     let(:metric_configuration) { FactoryGirl.build(:metric_configuration_with_id) }
-    let(:configuration) { FactoryGirl.build(:configuration_with_id) }
+    let(:kalibro_configuration) { FactoryGirl.build(:kalibro_configuration_with_id) }
 
     before :each do
       KalibroClient::Entities::Configurations::MetricConfiguration.
       expects(:request).
-      with('', {}, :get, "kalibro_configurations/#{configuration.id}").
+      with('', {}, :get, "kalibro_configurations/#{kalibro_configuration.id}").
       returns({'metric_configurations' => [metric_configuration.to_hash]})
     end
 
     it 'should return a array with a metric configuration' do
-      metric_configurations = KalibroClient::Entities::Configurations::MetricConfiguration.metric_configurations_of(configuration.id)
+      metric_configurations = KalibroClient::Entities::Configurations::MetricConfiguration.metric_configurations_of(kalibro_configuration.id)
 
       expect(metric_configurations).to be_an(Array)
       expect(metric_configurations.first.id).to eq(metric_configuration.id)
@@ -213,12 +197,10 @@ describe KalibroClient::Entities::Configurations::MetricConfiguration do
 
     context 'with an inexistant MetricConfiguration' do
       before :each do
-        any_code = rand(Time.now.to_i)
-        any_error_message = ""
         KalibroClient::Entities::Configurations::MetricConfiguration.
         expects(:request).
         with(':id', {id: metric_configuration.id}, :get).
-        returns({'error' => 'RecordNotFound'})
+        returns({'errors' => 'RecordNotFound'})
       end
 
       it 'should raise the RecordNotFound error' do
@@ -227,4 +209,21 @@ describe KalibroClient::Entities::Configurations::MetricConfiguration do
       end
     end
   end
+
+  describe 'kalibro ranges' do
+    let(:metric_configuration) { FactoryGirl.build(:metric_configuration_with_id) }
+    let(:kalibro_range_1) { FactoryGirl.build(:range, metric_configuration_id: metric_configuration.id) }
+    let(:kalibro_range_2) { FactoryGirl.build(:range, metric_configuration_id: metric_configuration.id) }
+
+    before :each do
+      KalibroClient::Entities::Configurations::MetricConfiguration.
+      expects(:request).
+      with(':id/kalibro_ranges', {id: metric_configuration.id}, :get).
+      returns({'kalibro_ranges' => [kalibro_range_1.to_hash, kalibro_range_2.to_hash]})
+    end
+
+    it 'should return the kalibro ranges of a metric configuration' do
+      expect(metric_configuration.kalibro_ranges).to eq([kalibro_range_1, kalibro_range_2])
+    end
+  end
 end

data/spec/entities/configurations/reading_group_spec.rb

@@ -57,4 +57,31 @@ describe KalibroClient::Entities::Configurations::ReadingGroup do
       end
     end
   end
+
+  describe 'readings' do
+    let(:reading_group) { FactoryGirl.build(:reading_group_with_id) }
+
+    context 'with readings' do
+      let(:reading_1) { FactoryGirl.build(:reading, reading_group_id: reading_group.id) }
+      let(:reading_2) { FactoryGirl.build(:reading, reading_group_id: reading_group.id) }
+
+      before :each do
+        KalibroClient::Entities::Configurations::ReadingGroup.expects(:request).with(":id/readings", {id: reading_group.id}, :get).returns({"readings" => [reading_1.to_hash, reading_2.to_hash]})
+      end
+
+      it 'should return an array of readings' do
+        expect(reading_group.readings).to eq([reading_1, reading_2])
+      end
+    end
+
+    context 'without readings' do
+      before :each do
+        KalibroClient::Entities::Configurations::ReadingGroup.expects(:request).with(":id/readings", {id: reading_group.id}, :get).returns({"readings" => []})
+      end
+
+      it 'should return an empty array' do
+        expect(reading_group.readings).to eq([])
+      end
+    end
+  end
 end

data/spec/entities/configurations/reading_spec.rb

@@ -24,13 +24,6 @@ describe KalibroClient::Entities::Configurations::Reading do
     end
   end
 
-  describe "grade=" do
-    it 'should set the grade attribute as a float' do
-      subject.grade = "44.7"
-      expect(subject.grade).to eq(44.7)
-    end
-  end
-
   context 'static methods' do
     let(:reading) { FactoryGirl.build(:reading_with_id) }
     describe 'readings_of' do
@@ -84,4 +77,19 @@ describe KalibroClient::Entities::Configurations::Reading do
       subject.destroy
     end
   end
+
+  # The only purpose of this test is to cover the overridden update_prefix method
+  describe 'update' do
+    subject {FactoryGirl.build(:reading_with_id)}
+
+    before :each do
+      KalibroClient::Entities::Configurations::Reading.
+        expects(:request).
+        with(":id", {reading: subject.to_hash, id: subject.id}, :put, "reading_groups/#{subject.reading_group_id}").returns({})
+    end
+
+    it 'should make a request to update' do
+      subject.update
+    end
+  end
 end

data/spec/entities/processor/metric_collector_details_spec.rb

@@ -119,11 +119,10 @@ describe KalibroClient::Entities::Processor::MetricCollectorDetails do
   end
 
   describe 'Supported Metrics' do
-    let(:code_and_metric) { { "total_abstract_classes" => FactoryGirl.build(:metric) } }
-    #FIXME: Mocha is creating the expectations with strings, but FactoryGirl returns everything with sybols and integers
-    let(:code_and_metric_parameter) { { "total_abstract_classes" => Hash[FactoryGirl.attributes_for(:metric)] } }
+    let(:code_and_metric) { { "total_abstract_classes" => FactoryGirl.build(:loc) } }
+    let(:code_and_metric_parameter) { { "total_abstract_classes" => FactoryGirl.build(:loc).to_hash } }
 
-    context 'supported_metrics acessors' do
+    context 'supported_metrics accessors' do
       it 'should set the value of the array of supported metrics' do
         subject.supported_metrics = code_and_metric_parameter
         expect(subject.supported_metrics["total_abstract_classes"].to_hash).to eql(code_and_metric["total_abstract_classes"].to_hash)
@@ -131,16 +130,29 @@ describe KalibroClient::Entities::Processor::MetricCollectorDetails do
     end
   end
 
-  describe 'metric' do
+  describe 'find_metric_by_name' do
     subject { FactoryGirl.build(:metric_collector_details) }
     let(:metric) { subject.supported_metrics["loc"] }
 
     it 'should return nil with an inexistent name' do
-      expect(subject.metric("fake name")).to be_nil
+      expect(subject.find_metric_by_name("fake name")).to be_nil
     end
 
     it 'should return a metric with an existent name' do
-      expect(subject.metric(metric.name).name).to eq(metric.name)
+      expect(subject.find_metric_by_name(metric.name)).to eq(metric)
+    end
+  end
+
+  describe 'find_metric_by_code' do
+    subject { FactoryGirl.build(:metric_collector_details) }
+    let(:metric) { subject.supported_metrics["loc"] }
+
+    it 'should return nil with an inexistent code' do
+      expect(subject.find_metric_by_code("fake code")).to be_nil
+    end
+
+    it 'should return a metric with an existent code' do
+      expect(subject.find_metric_by_code(metric.code)).to eq(metric)
     end
   end
 end