fortnox-api 0.5.2 → 0.6.0

data/spec/fortnox/api/repositories/customer_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'fortnox/api'
 require 'fortnox/api/mappers'
@@ -11,9 +13,9 @@ require 'fortnox/api/repositories/examples/search'
 describe Fortnox::API::Repository::Customer, order: :defined, integration: true do
   include Helpers::Configuration
 
-  before{ set_api_test_configuration }
+  before { set_api_test_configuration }
 
-  subject(:repository){ described_class.new }
+  subject(:repository) { described_class.new }
 
   include_examples '.save', :name
 
@@ -28,10 +30,10 @@ describe Fortnox::API::Repository::Customer, order: :defined, integration: true
   include_examples '.all', 100
 
   include_examples '.find', '1' do
-    let( :find_by_hash_failure ){ { city: 'Not Found' } }
-    let( :single_param_find_by_hash ){ { find_hash: { city: 'New York' }, matches: 2 } }
+    let(:find_by_hash_failure) { { city: 'Not Found' } }
+    let(:single_param_find_by_hash) { { find_hash: { city: 'New York' }, matches: 2 } }
 
-    let( :multi_param_find_by_hash ) do
+    let(:multi_param_find_by_hash) do
       { find_hash: { city: 'New York', zipcode: '10001' }, matches: 1 }
     end
   end

data/spec/fortnox/api/repositories/examples/all.rb

@@ -1,16 +1,17 @@
-# rubocop:disable RSpec/DescribeClass
+# frozen_string_literal: true
+
 RSpec.shared_examples_for '.all' do |count|
   describe '.all' do
     let(:response) do
-      VCR.use_cassette( "#{ vcr_dir }/all" ){ subject.all }
+      VCR.use_cassette("#{vcr_dir}/all") { subject.all }
     end
 
     specify 'returns correct number of records' do
-      expect( response.size ).to be count
+      expect(response.size).to be count
     end
 
     specify 'returns correct class' do
-      expect( response.first.class ).to be described_class::MODEL
+      expect(response.first.class).to be described_class::MODEL
     end
   end
 end

data/spec/fortnox/api/repositories/examples/find.rb

@@ -1,78 +1,87 @@
-shared_examples_for '.find' do |searched_entity_id|
+# frozen_string_literal: true
+
+shared_examples_for '.find' do |searched_entity_id, find_by_hash: true|
   describe '.find by id' do
-    let( :returned_object ) do
-      VCR.use_cassette( "#{ vcr_dir }/find_id_1" ){ repository.find( searched_entity_id ) }
+    let(:returned_object) do
+      VCR.use_cassette("#{vcr_dir}/find_id_1") { repository.find(searched_entity_id) }
     end
 
     context 'when found' do
       describe 'returned object' do
-        subject{ returned_object }
-        it{ is_expected.to be_saved }
-        it{ is_expected.not_to be_new }
+        subject { returned_object }
+
+        it { is_expected.to be_saved }
+        it { is_expected.not_to be_new }
       end
 
       describe 'class' do
-        subject{ returned_object.class }
-        it{ is_expected.to be described_class::MODEL }
+        subject { returned_object.class }
+
+        it { is_expected.to be described_class::MODEL }
       end
 
       describe 'unique id' do
-        subject{ returned_object.unique_id }
-        it{ is_expected.to eq searched_entity_id }
+        subject { returned_object.unique_id }
+
+        it { is_expected.to eq searched_entity_id }
       end
     end
 
     context 'when not found' do
-      subject{ find_failure }
+      subject { find_failure }
 
-      let( :not_found_id ){ '123456789' }
-      let( :find_failure ) do
+      let(:not_found_id) { '123456789' }
+      let(:find_failure) do
         when_performing do
-          VCR.use_cassette( "#{ vcr_dir }/find_failure" ){ repository.find( not_found_id ) }
+          VCR.use_cassette("#{vcr_dir}/find_failure") { repository.find(not_found_id) }
         end
       end
 
-      it{ is_expected.to raise_error( Fortnox::API::RemoteServerError, /Kan inte hitta /) }
+      it { is_expected.to raise_error(Fortnox::API::RemoteServerError, /Kan inte hitta /) }
     end
   end
 
-  describe '.find by hash' do
-    context 'when found' do
-      let( :returned_array ) do
-        VCR.use_cassette( "#{ vcr_dir }/#{ cassette }" ){ repository.find( find_hash ) }
-      end
+  if find_by_hash
+    describe '.find by hash' do
+      context 'when found' do
+        let(:returned_array) do
+          VCR.use_cassette("#{vcr_dir}/#{cassette}") { repository.find(find_hash) }
+        end
 
-      context 'with single parameter' do
-        let( :cassette ){ 'single_param_find_by_hash' }
-        let( :find_hash ){ single_param_find_by_hash[:find_hash] }
+        context 'with single parameter' do
+          let(:cassette) { 'single_param_find_by_hash' }
+          let(:find_hash) { single_param_find_by_hash[:find_hash] }
 
-        describe 'returned array size' do
-          subject{ returned_array.size }
-          it{ is_expected.to eq single_param_find_by_hash[:matches] }
+          describe 'returned array size' do
+            subject { returned_array.size }
+
+            it { is_expected.to eq single_param_find_by_hash[:matches] }
+          end
         end
-      end
 
-      context 'with multiple parameters' do
-        let( :cassette ){ 'multi_param_find_by_hash' }
-        let( :find_hash ){ multi_param_find_by_hash[:find_hash] }
+        context 'with multiple parameters' do
+          let(:cassette) { 'multi_param_find_by_hash' }
+          let(:find_hash) { multi_param_find_by_hash[:find_hash] }
 
-        describe 'returned array size' do
-          subject{ returned_array.size }
-          it{ is_expected.to eq multi_param_find_by_hash[:matches] }
+          describe 'returned array size' do
+            subject { returned_array.size }
+
+            it { is_expected.to eq multi_param_find_by_hash[:matches] }
+          end
         end
       end
-    end
 
-    context 'when not found' do
-      subject{ find_failure }
+      context 'when not found' do
+        subject { find_failure }
 
-      let( :find_failure ) do
-        VCR.use_cassette( "#{ vcr_dir }/find_by_hash_failure" ) do
-          repository.find( find_by_hash_failure )
+        let(:find_failure) do
+          VCR.use_cassette("#{vcr_dir}/find_by_hash_failure") do
+            repository.find(find_by_hash_failure)
+          end
         end
-      end
 
-      it{ is_expected.to eq [] }
+        it { is_expected.to eq [] }
+      end
     end
   end
 end

data/spec/fortnox/api/repositories/examples/only.rb

@@ -1,41 +1,42 @@
-# rubocop:disable RSpec/DescribeClass
+# frozen_string_literal: true
+
 shared_examples_for '.only' do |matching_filter, expected_matches, missing_filter: nil|
   describe '.only' do
     def repository_only(repository, vcr_cassette, filter)
-      VCR.use_cassette( "#{ vcr_dir }/#{ vcr_cassette }" ) do
-        repository.only( filter )
+      VCR.use_cassette("#{vcr_dir}/#{vcr_cassette}") do
+        repository.only(filter)
       end
     end
 
     shared_examples '.only response' do |vcr_cassette, expected_entries|
-      subject{ repository_only( repository, vcr_cassette, filter ) }
+      subject { repository_only(repository, vcr_cassette, filter) }
 
-      it{ is_expected.to be_instance_of( Array ) }
-      it{ is_expected.to have(expected_entries).entries }
+      it { is_expected.to be_instance_of(Array) }
+      it { is_expected.to have(expected_entries).entries }
     end
 
     unless missing_filter.nil?
-      context "with no matches" do
+      context 'with no matches' do
         include_examples '.only response', 'filter_miss', 0 do
-          let(:filter){ missing_filter }
+          let(:filter) { missing_filter }
         end
       end
     end
 
-    context "with matches" do
+    context 'with matches' do
       include_examples '.only response', 'filter_hit', expected_matches do
-        let(:filter){ matching_filter }
+        let(:filter) { matching_filter }
       end
     end
 
-    context "with invalid filter" do
+    context 'with invalid filter' do
       subject do
         when_performing do
-          repository_only( repository, 'filter_invalid', 'doesntexist' )
+          repository_only(repository, 'filter_invalid', 'doesntexist')
         end
       end
 
-      it{ is_expected.to raise_error( Fortnox::API::RemoteServerError, /ogiltigt filter/ ) }
+      it { is_expected.to raise_error(Fortnox::API::RemoteServerError, /ogiltigt filter/) }
     end
   end
 end

data/spec/fortnox/api/repositories/examples/save.rb

@@ -1,65 +1,59 @@
+# frozen_string_literal: true
+
 #######################################
 # SPEC IS DEPENDENT ON DEFINED ORDER!
 #######################################
 #
 # Assumes that attribute is a string attribute without restrictions.
-
-# rubocop:disable RSpec/DescribeClass
 shared_examples_for '.save' do |attribute, additional_attrs: {}|
   describe '.save' do
-    let( :new_hash ){ additional_attrs.merge( attribute => value ) }
-    let( :new_model ){ described_class::MODEL.new( new_hash ) }
-    let( :save_new ){ VCR.use_cassette( "#{ vcr_dir }/save_new" ){ repository.save( new_model ) } }
-    let( :entity_wrapper ){ repository.mapper.class::JSON_ENTITY_WRAPPER }
-    let( :value ){ 'A value' }
+    let(:new_hash) { additional_attrs.merge(attribute => value) }
+    let(:new_model) { described_class::MODEL.new(new_hash) }
+    let(:save_new) { VCR.use_cassette("#{vcr_dir}/save_new") { repository.save(new_model) } }
+    let(:entity_wrapper) { repository.mapper.class::JSON_ENTITY_WRAPPER }
+    let(:value) { 'A value' }
 
     shared_examples_for 'save' do
       before do
         if model.saved?
           message = 'Test trying to save model, but already marked as saved!'
-          message << " Model: #{ model.inspect }"
-          fail(message)
+          message << " Model: #{model.inspect}"
+          raise(message)
         end
       end
 
-      specify "includes correct #{ attribute.inspect }" do
+      specify "includes correct #{attribute.inspect}" do
         saved_entity = send_request
-        expect( saved_entity.send(attribute) ).to eql( value )
+        expect(saved_entity.send(attribute)).to eql(value)
       end
     end
 
     describe 'new' do
       context 'when not saved' do
         include_examples 'save' do
-          let( :model ){ new_model }
-          let( :send_request ){ save_new }
+          let(:model) { new_model }
+          let(:send_request) { save_new }
         end
       end
 
-      context "saved #{ described_class::MODEL }" do
-        let( :hash ){ { unsaved: false }.merge(new_hash) }
-        let( :model ){ described_class::MODEL.new( hash ) }
-
-        before do
-          # Should not make an API request in test!
-          expect( repository ).not_to receive( :save_new )
-          expect( repository ).not_to receive( :update_existing )
-        end
+      context "saved #{described_class::MODEL}" do
+        let(:hash) { { unsaved: false }.merge(new_hash) }
+        let(:model) { described_class::MODEL.new(hash) }
 
-        specify{ expect( repository.save( model )).to be( true ) }
+        specify { expect(repository.save(model)).to be(true) }
       end
     end
 
     describe 'old (update existing)' do
       include_examples 'save' do
-        let( :value ){ "Updated #{ attribute }" }
-        let( :model ) do
+        let(:value) { "Updated #{attribute}" }
+        let(:model) do
           new_id = save_new.unique_id
-          new_record = VCR.use_cassette( "#{ vcr_dir }/find_new" ){ repository.find( new_id ) }
-          new_record.update( attribute => value )
+          new_record = VCR.use_cassette("#{vcr_dir}/find_new") { repository.find(new_id) }
+          new_record.update(attribute => value)
         end
-        let( :send_request ) do
-          VCR.use_cassette( "#{ vcr_dir }/save_old" ){ repository.save( model ) }
+        let(:send_request) do
+          VCR.use_cassette("#{vcr_dir}/save_old") { repository.save(model) }
         end
       end
     end

data/spec/fortnox/api/repositories/examples/save_with_nested_model.rb

@@ -1,26 +1,26 @@
+# frozen_string_literal: true
+
 # TODO: This will not work until we solve issue #62.
 # Until then, these tests are pending.
-
-# rubocop:disable RSpec/DescribeClass
 shared_examples_for '.save with nested model' do |required_hash, nested_model_key, nested_model_hash, nested_entity|
   describe '.save with nested model' do
-    let( :repository ){ described_class.new }
-    let( :new_hash ) do
-      required_hash.merge( nested_model_key => nested_entity )
+    let(:repository) { described_class.new }
+    let(:new_hash) do
+      required_hash.merge(nested_model_key => nested_entity)
     end
-    let( :response ) do
-      VCR.use_cassette( "#{ vcr_dir }/save_with_nested_model" ) do
-        model = described_class::MODEL.new( new_hash )
-        repository.save( model )
+    let(:response) do
+      VCR.use_cassette("#{vcr_dir}/save_with_nested_model") do
+        model = described_class::MODEL.new(new_hash)
+        repository.save(model)
       end
     end
 
     it 'does not raise any errors' do
-      expect{ response }.not_to raise_error
+      expect { response }.not_to raise_error
     end
 
     describe 'returned entity\'s nested model' do
-      subject(:returned_nested_model){ response.send(nested_model_key).first }
+      subject(:returned_nested_model) { response.send(nested_model_key).first }
 
       it 'has the wanted attributes' do
         nested_model_hash.each do |attribute, value|

data/spec/fortnox/api/repositories/examples/save_with_specially_named_attribute.rb

@@ -1,26 +1,27 @@
+# frozen_string_literal: true
+
 # Test saving model with attributes that has specially names that needs to be mapped.
 #
 # NOTE: VCR cassette must be discarded when repositories are updated to reflect
 # the changes!
-
-# rubocop:disable RSpec/DescribeClass
 shared_examples_for '.save with specially named attribute' do |required_hash, attribute, value|
   describe '.save' do
     context 'with specially named attribute' do
-      subject{ ->{ save_model } }
+      subject { -> { save_model } }
 
-      let( :new_model ){ described_class::MODEL.new( required_hash.merge(attribute => value) ) }
-      let( :save_model )do
-        VCR.use_cassette( "#{ vcr_dir }/save_with_specially_named_attribute" ) do
-            repository.save( new_model )
+      let(:new_model) { described_class::MODEL.new(required_hash.merge(attribute => value)) }
+      let(:save_model) do
+        VCR.use_cassette("#{vcr_dir}/save_with_specially_named_attribute") do
+          repository.save(new_model)
         end
       end
 
-      it{ is_expected.not_to raise_error }
+      it { is_expected.not_to raise_error }
 
       describe 'response' do
-        subject{ save_model.send(attribute) }
-        it{ is_expected.to eq(value) }
+        subject { save_model.send(attribute) }
+
+        it { is_expected.to eq(value) }
       end
     end
   end

data/spec/fortnox/api/repositories/examples/search.rb

@@ -1,40 +1,40 @@
-# rubocop:disable RSpec/DescribeClass
+# frozen_string_literal: true
+
 shared_examples_for '.search' do |attribute_hash_key_name, value, matches|
   describe '.search' do
-
     describe 'search' do
-      context "with no matches" do
+      context 'with no matches' do
         subject do
-          VCR.use_cassette( "#{ vcr_dir }/search_miss" ) do
-            repository.search( attribute_hash_key_name => 'nothing' )
+          VCR.use_cassette("#{vcr_dir}/search_miss") do
+            repository.search(attribute_hash_key_name => 'nothing')
           end
         end
 
-        it{ is_expected.to be_instance_of( Array ) }
-        it{ is_expected.to have(0).entries }
+        it { is_expected.to be_instance_of(Array) }
+        it { is_expected.to have(0).entries }
       end
 
-      context "with #{ matches } match(es)" do
+      context "with #{matches} match(es)" do
         subject do
-          VCR.use_cassette( "#{ vcr_dir }/search_by_name" ) do
-            repository.search( attribute_hash_key_name => value )
+          VCR.use_cassette("#{vcr_dir}/search_by_name") do
+            repository.search(attribute_hash_key_name => value)
           end
         end
 
-        it{ is_expected.to be_instance_of( Array) }
-        it{ is_expected.to have(matches).entries }
+        it { is_expected.to be_instance_of(Array) }
+        it { is_expected.to have(matches).entries }
       end
 
       context 'with special characters' do
         subject do
           when_performing do
-            VCR.use_cassette( "#{ vcr_dir }/search_with_special_char") do
-              repository.search( attribute_hash_key_name => 'special char å' )
+            VCR.use_cassette("#{vcr_dir}/search_with_special_char") do
+              repository.search(attribute_hash_key_name => 'special char å')
             end
           end
         end
 
-        it{ is_expected.not_to raise_error }
+        it { is_expected.not_to raise_error }
       end
     end
   end