fortnox-api 0.8.2 → 0.9.0

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

@@ -2,380 +2,167 @@
 
 require 'spec_helper'
 require 'fortnox/api'
+require 'jwt'
+require 'dry/container/stub'
+
+describe Fortnox::API::Repository::Base, integration: true do
+  include Helpers::Configuration
 
-describe Fortnox::API::Repository::Base do
   before do
-    stub_const('Model::RepositoryBaseTest', Class.new)
-    stub_const('Repository::Test', Class.new(described_class))
-    stub_const('Repository::Test::MODEL', Model::RepositoryBaseTest)
+    stub_const('TestModel', Class.new)
+    stub_const('TestRepository', Class.new(described_class))
+    stub_const('TestRepository::MODEL', TestModel)
 
-    Fortnox::API::Registry.register(:repositorybasetest, Model::RepositoryBaseTest)
-  end
+    Fortnox::API::Registry.enable_stubs!
 
-  after do
-    # HACK: Currently, there is no way to remove keys from the Dry::Container#register.
-    # We could move the register call to a before(:all) hook, but that registered key
-    # would then leak into other tests. Instead, we can simply delete it with this little hack :)
-    Fortnox::API::Registry._container.delete('repositorybasetest')
+    add_to_registry(:testmodel, TestModel)
   end
 
-  let(:access_token) { '3f08d038-f380-4893-94a0-a08f6e60e67a' }
-  let(:access_token2) { '89feajou-sif8-8f8u-29ja-xdfniokeniod' }
-  let(:client_secret) { 'P5K5vE3Kun' }
-  let(:repository) { Repository::Test.new }
-  let(:application_json) {}
-  let(:headers) do
-    {
-      'Access-Token' => access_token,
-      'Client-Secret' => client_secret,
-      'Content-Type' => 'application/json',
-      'Accept' => 'application/json'
-    }
-  end
-
-  describe 'creation' do
-    shared_examples_for 'missing configuration' do
-      subject { -> { Repository::Test.new(token_store: :store1).get('nonsense') } }
-
-      let(:error) { Fortnox::API::MissingConfiguration }
-
-      it { is_expected.to raise_error(error, /#{message}/) }
-    end
-
-    context 'without base url' do
-      include_examples 'missing configuration' do
-        before do
-          Fortnox::API.configure do |config|
-            config.base_url = nil
-            config.client_secret = client_secret
-            config.access_tokens = { store1: access_token }
-          end
-        end
-
-        let(:message) { 'have to provide a base url' }
-      end
-    end
+  let(:repository) { TestRepository.new }
 
-    context 'without client secret' do
-      include_examples 'missing configuration' do
-        before do
-          Fortnox::API.configure do |config|
-            config.client_secret = nil
-            config.access_tokens = { store1: access_token }
-          end
-        end
+  describe '#initialize' do
+    context 'without providing an access token' do
+      before { Fortnox::API.access_token = nil }
 
-        let(:message) { 'have to provide your client secret' }
+      it 'raises an error' do
+        expect { TestRepository.new }.to raise_error(Fortnox::API::MissingAccessToken)
       end
     end
-  end
-
-  describe '#next_access_token' do
-    before { Fortnox::API.configure { |conf| conf.client_secret = client_secret } }
-
-    context 'with default token store' do
-      context 'with one access token' do
-        subject { repository.next_access_token }
-
-        before { Fortnox::API.configure { |conf| conf.access_token = access_token } }
-
-        it { is_expected.to eql(access_token) }
-      end
-
-      context 'with one access token and two subsequent requests' do
-        subject { repository.next_access_token }
-
-        before do
-          Fortnox::API.configure { |conf| conf.access_token = access_token }
-          repository.next_access_token
-        end
-
-        it 'still uses the same token' do
-          is_expected.to eql(access_token)
-        end
-      end
-
-      context 'with multiple access tokens' do
-        subject { access_tokens }
-
-        before { Fortnox::API.configure { |conf| conf.access_tokens = access_tokens } }
-        let(:access_tokens) { [access_token, access_token2] }
-
-        it { is_expected.to include(repository.next_access_token) }
-
-        it 'changes token on next request' do
-          token1 = repository.next_access_token
-          token2 = repository.next_access_token
-
-          expect(token1).not_to eql(token2)
-        end
-
-        it 'circulates tokens' do
-          token1 = repository.next_access_token
-          repository.next_access_token
-          token3 = repository.next_access_token
-
-          expect(token1).to eql(token3)
-        end
-      end
-    end
-
-    context 'with multiple stores' do
-      subject { repository.next_access_token }
-
-      before do
-        Fortnox::API.configure do |config|
-          config.access_tokens = { store1: access_token, store2: access_token2 }
-        end
-      end
 
-      describe 'first token store' do
-        let(:repository) { Repository::Test.new(token_store: :store1) }
+    context 'with expired access token' do
+      before { Fortnox::API.access_token = ENV.fetch('EXPIRED_ACCESS_TOKEN') }
 
-        it { is_expected.to eql access_token }
-      end
-
-      describe 'second token store' do
-        let(:repository) { Repository::Test.new(token_store: :store2) }
-
-        it { is_expected.to eql access_token2 }
+      it 'raises an error' do
+        expect do
+          VCR.use_cassette('authentication/expired_token') { repository.get('/customers', body: '') }
+        end.to raise_error(Fortnox::API::RemoteServerError, /Unauthorized request(.)*"message":"unauthorized"/)
       end
     end
   end
 
-  describe '#access_tokens' do
-    subject(:access_tokens) { repository.access_tokens }
-
-    before { Fortnox::API.configure { |conf| conf.client_secret = client_secret } }
-
-    let(:token_store_not_present) do
-      "There is no token store named #{token_store.inspect}. Available stores are #{available_stores}."
-    end
-
-    let(:error) { Fortnox::API::MissingConfiguration }
-
-    context 'with non existing token store' do
-      subject { -> { access_tokens } }
-
-      before do
-        Fortnox::API.configure { |conf| conf.access_tokens = { some_store: [access_token] } }
-      end
-
-      let(:repository) { Repository::Test.new(token_store: token_store) }
-      let(:token_store) { :non_existing_store }
-      let(:available_stores) { [:some_store] }
-
-      it { is_expected.to raise_error(error, token_store_not_present) }
-    end
-
-    context 'with no tokens set' do
-      subject { -> { access_tokens } }
-
-      before { Fortnox::API.configure { |conf| conf.access_tokens = {} } }
-      let(:token_store) { :default }
-      let(:available_stores) { [] }
-
-      it { is_expected.to raise_error(error, token_store_not_present) }
-    end
-
-    context 'with one access token in token store' do
-      before { Fortnox::API.configure { |conf| conf.access_token = access_token } }
-      let(:token_store) { :default }
-
-      it { is_expected.to eql(access_token) }
-    end
-
-    context 'with multiple access tokens' do
-      before do
-        Fortnox::API.configure { |conf| conf.access_tokens = [access_token, access_token2] }
-      end
-      let(:token_store) { :default }
-
-      it { is_expected.to eql([access_token, access_token2]) }
-    end
-
-    context 'with multiple token stores' do
-      before do
-        Fortnox::API.configure do |conf|
-          conf.access_tokens = { store_a: store_a_tokens, store_b: store_b_token }
-        end
-      end
-      let(:store_a_tokens) { %w[token_a1 token_a2] }
-      let(:store_b_token) { 'token_b1' }
-
-      context 'with valid store name' do
-        let(:repository) { Repository::Test.new(token_store: :store_a) }
-
-        it { is_expected.to eql(store_a_tokens) }
-      end
-
-      context 'with non collection' do
-        let(:repository) { Repository::Test.new(token_store: :store_b) }
-
-        it { is_expected.to eql(store_b_token) }
-      end
-
-      context 'with invalid store name' do
-        subject { -> { access_tokens } }
-
-        let(:repository) { Repository::Test.new(token_store: :nonsence_store) }
-
-        it { is_expected.to raise_error(error) }
-      end
-    end
-  end
-
-  describe '#check_access_tokens!' do
-    subject { -> { repository.check_access_tokens!(tokens) } }
-
-    before { Fortnox::API.configure { |conf| conf.client_secret = client_secret } }
-    let(:error) { Fortnox::API::MissingConfiguration }
-    let(:message) { "not provided any access tokens in token store #{token_store.inspect}" }
-    let(:token_store) { :default }
-
-    context 'with nil' do
-      let(:tokens) { nil }
-
-      it { is_expected.to raise_error(error, /#{message}/) }
-    end
-
-    context 'with empty array' do
-      let(:tokens) { [] }
-
-      it { is_expected.to raise_error(error, /#{message}/) }
-    end
-
-    context 'with an empty, non default, token store' do
-      before { Fortnox::API.configure { |conf| conf.access_tokens = { token_store => tokens } } }
-      let(:repository) { Repository::Test.new(token_store: token_store) }
-      let(:tokens) { [] }
-      let(:token_store) { :store1 }
-
-      it { is_expected.to raise_error(error, /#{message}/) }
-    end
-
-    context 'with valid tokens' do
-      let(:tokens) { %w[12345 abcde] }
-
-      it { is_expected.not_to raise_error }
-    end
-  end
-
   context 'when making a request including the proper headers' do
+    subject { repository.get('/test', body: '') }
+
     before do
-      Fortnox::API.configure do |conf|
-        conf.client_secret = client_secret
-        conf.access_token = access_token
-      end
+      set_api_test_configuration
 
       stub_request(
         :get,
         'https://api.fortnox.se/3/test'
-      ).with(
-        headers: headers
       ).to_return(
         status: 200
       )
     end
 
-    subject { repository.get('/test', body: '') }
-
     it { is_expected.to be_nil }
   end
 
-  describe 'making requests with multiple access tokens' do
+  context 'when receiving an error from remote server' do
     before do
-      Fortnox::API.configure do |conf|
-        conf.client_secret = client_secret
-        conf.access_tokens = [access_token, access_token2]
-      end
+      set_api_test_configuration
 
       stub_request(
-        :get,
+        :post,
         'https://api.fortnox.se/3/test'
-      ).with(
-        headers: {
-          'Access-Token' => access_token,
-          'Client-Secret' => client_secret,
-          'Content-Type' => 'application/json',
-          'Accept' => 'application/json'
-        }
       ).to_return(
-        status: 200,
-        body: '1'
+        status: 500,
+        body: {
+          'ErrorInformation' => {
+            'error' => 1,
+            'message' => 'some-error-message'
+          }
+        }.to_json,
+        headers: { 'Content-Type' => 'application/json' }
       )
+    end
 
-      stub_request(
-        :get,
-        'https://api.fortnox.se/3/test'
-      ).with(
-        headers: {
-          'Access-Token' => access_token2,
-          'Client-Secret' => client_secret,
-          'Content-Type' => 'application/json',
-          'Accept' => 'application/json'
-        }
-      ).to_return(
-        status: 200,
-        body: '2'
-      )
+    it 'raises an error' do
+      expect do
+        repository.post('/test', body: '')
+      end.to raise_error(Fortnox::API::RemoteServerError, /some-error-message/)
     end
 
-    context 'with subsequent requests on same object' do
-      let!(:response1) { repository.get('/test', body: '') }
-      let!(:response2) { repository.get('/test', body: '') }
-      let!(:response3) { repository.get('/test', body: '') }
+    context 'with debugging enabled' do
+      before { Fortnox::API.config.debugging = true }
+      after { Fortnox::API.config.debugging = false }
 
-      # rubocop:disable RSpec/MultipleExpectations
-      # All these checks must be run in same it-statement because
-      # of the random starting index.
-      it 'works' do
-        expect(response1).not_to eq(response2)
-        expect(response1).to eq(response3)
-        expect(response3).not_to eq(response2)
+      it do
+        expect do
+          repository.post('/test', body: '')
+        end.to raise_error(/<HTTParty::Request:0x/)
       end
-      # rubocop:enable RSpec/MultipleExpectations
     end
   end
 
-  context 'when raising error from remote server' do
-    error_message = 'Räkenskapsår finns inte upplagt. '\
-                    'För att kunna skapa en faktura krävs det att det finns ett räkenskapsår'
-
+  context 'when receiving HTML from remote server' do
     before do
-      Fortnox::API.configure do |conf|
-        conf.client_secret = client_secret
-        conf.access_tokens = [access_token, access_token2]
-      end
+      set_api_test_configuration
 
       stub_request(
-        :post,
-        'https://api.fortnox.se/3/test'
+        :get,
+        'https://api.fortnox.se/3nonsense'
       ).to_return(
-        status: 500,
-        body: {
-          'ErrorInformation' => {
-            'error' => 1,
-            'message' => error_message
-          }
-        }.to_json,
-        headers: { 'Content-Type' => 'application/json' }
+        status: 404,
+        body: "<html>\r\n" \
+              "<head><title>404 Not Found</title></head>\r\n" \
+              "<body>\r\n<center><h1>404 Not Found</h1></center>\r\n" \
+              "<hr><center>nginx</center>\r\n</body>\r\n</html>\r\n",
+        headers: { 'Content-Type' => 'text/html' }
       )
     end
 
-    subject { -> { repository.post('/test', body: '') } }
+    it 'raises an error' do
+      expect do
+        repository.get('nonsense')
+      end.to raise_error(Fortnox::API::RemoteServerError,
+                         %r{Fortnox API's response has content type "text/html"})
+    end
+  end
 
-    it { is_expected.to raise_error(Fortnox::API::RemoteServerError) }
-    it { is_expected.to raise_error(error_message) }
+  describe 'update existing' do
+    context 'with no change' do
+      before do
+        set_api_test_configuration
 
-    context 'with debugging enabled' do
-      around do |example|
-        Fortnox::API.config.debugging = true
-        example.run
-        Fortnox::API.config.debugging = false
+        stub_const(
+          'Product',
+          Class.new(Fortnox::API::Model::Base) do
+            attribute :name, 'strict.string'
+            attribute :description, 'string' # nullable
+          end
+        )
+        stub_const('Product::STUB', { name: '' }.freeze)
+        stub_const('Product::UNIQUE_ID', :name)
+
+        stub_const('ProductMapper', Class.new(Fortnox::API::Mapper::Base))
+        stub_const('ProductMapper::JSON_ENTITY_WRAPPER', 'Product')
+        stub_const('ProductMapper::JSON_COLLECTION_WRAPPER', 'Products')
+        stub_const('ProductMapper::KEY_MAP', {})
+
+        stub_const('TestRepository::MODEL', Product)
+        stub_const('TestRepository::MAPPER', ProductMapper)
+        stub_const('TestRepository::URI', '/test/')
+
+        Fortnox::API::Registry.enable_stubs!
+        add_to_registry(:product, ProductMapper)
+
+        stub_request(
+          :post,
+          'https://api.fortnox.se/3/test/'
+        ).to_return(
+          status: 200,
+          body: '{"Product" : {"Name": "test", "Desription": null}}',
+          headers: { 'Content-Type' => 'application/json' }
+        ).times(1) # Only stub the first save request
+      end
+
+      let(:updated_entity) do
+        repository.save(Product.new(name: 'test')).update({ description: nil })
       end
 
-      it { is_expected.to raise_error(/\<HTTParty\:\:Request\:0x/) }
+      it 'does not call Fortnox' do
+        expect { repository.save(updated_entity) }.not_to raise_error
+      end
     end
   end
 end

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

@@ -10,13 +10,14 @@ require 'fortnox/api/repositories/examples/save'
 require 'fortnox/api/repositories/examples/save_with_specially_named_attribute'
 require 'fortnox/api/repositories/examples/search'
 
-describe Fortnox::API::Repository::Customer, order: :defined, integration: true do
+describe Fortnox::API::Repository::Customer, integration: true, order: :defined do
   include Helpers::Configuration
-
-  before { set_api_test_configuration }
+  include Helpers::Repositories
 
   subject(:repository) { described_class.new }
 
+  before { set_api_test_configuration }
+
   include_examples '.save', :name
 
   include_examples '.save with specially named attribute',
@@ -24,11 +25,12 @@ describe Fortnox::API::Repository::Customer, order: :defined, integration: true
                    :email_invoice_cc,
                    'test@example.com'
 
-  # It is not yet possible to delete Customers. Therefore, expected nr of
+  # VCR: It is not yet possible to delete Customers. Therefore, expected nr of
   # Customers when running .all will continue to increase
   # (until 100, which is max by default).
-  include_examples '.all', 100
+  include_examples '.all', 7
 
+  # VCR: Searched Customers needs to be created manually
   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 } }
@@ -38,8 +40,8 @@ describe Fortnox::API::Repository::Customer, order: :defined, integration: true
     end
   end
 
-  # When recording new VCR casettes, expected matches must be increased
-  include_examples '.search', :name, 'Test', 33
+  # NOTE: When recording new VCR casettes, expected matches must be increased
+  include_examples '.search', :name, 'Test', 2
 
   describe 'country reference' do
     describe 'with valid country code \'SE\'' do
@@ -67,4 +69,32 @@ describe Fortnox::API::Repository::Customer, order: :defined, integration: true
       end
     end
   end
+
+  describe 'sales account' do
+    # VCR: The Sales Account needs to be created manually in Fortnox
+    context 'when saving a Customer with a Sales Account set' do
+      let(:customer) do
+        VCR.use_cassette("#{vcr_dir}/save_new_with_sales_account") do
+          repository.save(
+            described_class::MODEL.new(
+              name: 'Customer with Sales Account',
+              sales_account: '3001'
+            )
+          )
+        end
+      end
+
+      context 'when fetching that Customer' do
+        subject { fetched_customer.sales_account }
+
+        let(:fetched_customer) do
+          VCR.use_cassette("#{vcr_dir}/find_with_sales_account") do
+            repository.find(customer.customer_number)
+          end
+        end
+
+        it { is_expected.to eq('3001') }
+      end
+    end
+  end
 end

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

@@ -15,4 +15,3 @@ RSpec.shared_examples_for '.all' do |count|
     end
   end
 end
-# rubocop:enable RSpec/DescribeClass

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

@@ -28,16 +28,13 @@ shared_examples_for '.find' do |searched_entity_id, find_by_hash: true|
     end
 
     context 'when not found' do
-      subject { find_failure }
-
-      let(:not_found_id) { '123456789' }
-      let(:find_failure) do
-        when_performing do
-          VCR.use_cassette("#{vcr_dir}/find_failure") { repository.find(not_found_id) }
-        end
+      let(:find_with_non_existing_id) do
+        VCR.use_cassette("#{vcr_dir}/find_failure") { repository.find('123456789') }
       end
 
-      it { is_expected.to raise_error(Fortnox::API::RemoteServerError, /Kan inte hitta /) }
+      specify do
+        expect { find_with_non_existing_id }.to raise_error(Fortnox::API::RemoteServerError, /Kan inte hitta /)
+      end
     end
   end
 

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

@@ -2,14 +2,8 @@
 
 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)
-      end
-    end
-
     shared_examples '.only response' do |vcr_cassette, expected_entries|
-      subject { repository_only(repository, vcr_cassette, filter) }
+      subject { VCR.use_cassette("#{vcr_dir}/#{vcr_cassette}") { repository.only(filter) } }
 
       it { is_expected.to be_instance_of(Array) }
       it { is_expected.to have(expected_entries).entries }
@@ -30,14 +24,11 @@ shared_examples_for '.only' do |matching_filter, expected_matches, missing_filte
     end
 
     context 'with invalid filter' do
-      subject do
-        when_performing do
-          repository_only(repository, 'filter_invalid', 'doesntexist')
-        end
+      let(:only_with_invalid_filter) do
+        VCR.use_cassette("#{vcr_dir}/filter_invalid") { repository.only('doesntexist') }
       end
 
-      it { is_expected.to raise_error(Fortnox::API::RemoteServerError, /ogiltigt filter/) }
+      specify { expect { only_with_invalid_filter }.to raise_error(Fortnox::API::RemoteServerError, /ogiltigt filter/) }
     end
   end
 end
-# rubocop:enable RSpec/DescribeClass