fortnox-api 0.8.0 → 0.9.0

data/spec/fortnox/api/mappers/base/to_json_spec.rb

@@ -5,73 +5,64 @@ require 'fortnox/api/mappers/base/to_json'
 require 'fortnox/api/mappers/contexts/json_conversion'
 
 describe Fortnox::API::Mapper::ToJSON do
-  # TODO: Following error is risen sometimes when all specs are run:
-  # "NoMethodError: undefined method `call\' for Test::ProductMapper:Class`"
-  it 'should be tested when random error is fixed!'
+  include_context 'with JSON conversion'
 
-  describe 'wrap_entity_json_hash' do
-    it 'should be tested'
+  before do
+    Test::BaseMapper.class_eval do
+      include Fortnox::API::Mapper::ToJSON # rubocop:disable RSpec/DescribedClass
+    end
   end
 
-  # include_context 'with JSON conversion'
+  let(:mapper) { Test::ProductMapper.new }
 
-  # before do
-  #   module Test
-  #     class BaseMapper
-  #       include Fortnox::API::Mapper::ToJSON
-  #     end
-  #   end
-  # end
+  describe '#entity_to_hash' do
+    let(:product) do
+      category1 = Test::Category.new(name: 'Cars', id: '1')
+      category2 = Test::Category.new(name: 'Fast Cars', id: '2')
+      product_designer = Test::ProductDesigner.new(name: 'John Najjar', id: '23')
 
-  # let( :mapper ){ Test::ProductMapper.new }
+      Test::Product.new(url: 'someurl@example.com',
+                        name: 'Ford Mustang',
+                        vat: 30_000.0,
+                        categories: [category1, category2],
+                        designer: product_designer)
+    end
+    let(:keys_to_filter) { [:url] }
+    let(:returned_hash) { mapper.entity_to_hash(product, keys_to_filter) }
+    let(:inner_hash) { returned_hash['Product'] }
 
-  # describe 'entity_to_hash' do
-  #   let( :category1 ){ Test::Category.new( name: 'Cars', id: '1' ) }
-  #   let( :category2 ){ Test::Category.new( name: 'Fast Cars', id: '2' ) }
-  #   let( :product_designer ){ Test::ProductDesigner.new( name: 'John Najjar', id: '23' ) }
-  #   let( :product ) do
-  #     Test::Product.new( url: 'someurl@example.com',
-  #                        name: 'Ford Mustang',
-  #                        vat: 30000.0 ,
-  #                        categories: [category1, category2],
-  #                        designer: product_designer )
-  #   end
-  #   let( :keys_to_filter ){ [:url] }
-  #   let( :returned_hash ){ mapper.entity_to_hash( product, keys_to_filter ) }
-  #   let( :inner_hash ){ returned_hash['Product'] }
+    it 'includes JSON entity wrapper' do
+      expect(returned_hash).to have_key('Product')
+    end
 
-  #   it 'includes JSON entity wrapper' do
-  #     expect( returned_hash ).to have_key( 'Product' )
-  #   end
+    describe 'keys without mapping' do
+      specify 'converts correctly' do
+        expect(inner_hash['Name']).to eq('Ford Mustang')
+      end
+    end
 
-  #   context 'with keys without mapping' do
-  #     specify 'converts correctly' do
-  #       expect( inner_hash['Name'] ).to eq( 'Ford Mustang' )
-  #     end
-  #   end
+    describe 'keys to filter' do
+      specify 'filteres out those keys' do
+        expect(inner_hash).not_to have_key('@url')
+      end
+    end
 
-  #   context 'with keys to filter' do
-  #     specify 'filteres out those keys' do
-  #       expect( inner_hash ).not_to have_key( '@url' )
-  #     end
-  #   end
+    describe 'nested models' do
+      let(:expected_nested_model_hash) do
+        [{ 'Name' => 'Cars', 'ID' => '1' }, { 'Name' => 'Fast Cars', 'ID' => '2' }]
+      end
 
-  #   context 'with nested models' do
-  #     let( :expected_nested_model_hash ) do
-  #       [{"Name" => "Cars", "ID" => "1"}, {"Name" => "Fast Cars", "ID" => "2"}]
-  #     end
+      specify 'are converted correctly' do
+        expect(inner_hash['Categories']).to eq(expected_nested_model_hash)
+      end
+    end
 
-  #     specify 'are converted correctly' do
-  #       expect( inner_hash['Categories'] ).to eq( expected_nested_model_hash )
-  #     end
-  #   end
+    describe 'nested model' do
+      let(:expected_nested_model_hash) { { 'Name' => 'John Najjar', 'ID' => '23' } }
 
-  #   context 'with nested model' do
-  #     let( :expected_nested_model_hash ){ { 'Name' => 'John Najjar', 'ID' => '23' } }
-
-  #     specify 'is converted correctly' do
-  #       expect( inner_hash['Designer'] ).to eq( expected_nested_model_hash )
-  #     end
-  #   end
-  # end
+      specify 'is converted correctly' do
+        expect(inner_hash['Designer']).to eq(expected_nested_model_hash)
+      end
+    end
+  end
 end

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

@@ -99,6 +99,7 @@ describe Fortnox::API::Mapper::Base do
       let(:value) { true }
     end
   end
+
   describe 'falseclass' do
     include_examples 'identity mapper', :falseclass do
       let(:value) { false }
@@ -126,17 +127,15 @@ describe Fortnox::API::Mapper::Base do
 
     describe 'special cases' do
       context 'with SE' do
-        subject { mapper.call('SE') }
-
         it 'translates code to country name in Swedish' do
-          is_expected.to eq('Sverige')
+          expect(mapper.call('SE')).to eq('Sverige')
         end
       end
 
       context 'with nil value' do
         subject { mapper.call(nil) }
 
-        it { is_expected.to eq(nil) }
+        it { is_expected.to be_nil }
       end
 
       context 'with empty string' do
@@ -146,10 +145,8 @@ describe Fortnox::API::Mapper::Base do
       end
 
       context 'with nonsense' do
-        subject { -> { mapper.call('nonsense') } }
-
         it 'is not supported (since input is sanitised) and therefore blows up' do
-          raise_error(NoMethodError)
+          expect { mapper.call('nonsense') }.to raise_error(NoMethodError)
         end
       end
     end

data/spec/fortnox/api/mappers/contexts/json_conversion.rb

@@ -2,56 +2,61 @@
 
 require 'fortnox/api'
 require 'fortnox/api/mappers'
+require 'dry/container/stub'
 
 shared_context 'with JSON conversion' do
-  before do
-    module Test
-      class BaseMapper
-      end
-
-      class CategoryMapper < BaseMapper
-        KEY_MAP = { id: 'ID' }.freeze
-      end
-
-      class ProductDesignerMapper < BaseMapper
-        KEY_MAP = { id: 'ID' }.freeze
-      end
-
-      class ProductMapper < BaseMapper
-        KEY_MAP = {
-          vat: 'VAT',
-          url: '@url' # TODO: How to handle url attribute?
-        }.freeze
-        JSON_ENTITY_WRAPPER = 'Product'
-        JSON_COLLECTION_WRAPPER = 'Products'
-      end
+  include Helpers::Configuration
 
-      class Category < Fortnox::API::Model::Base
+  before do
+    stub_const('Test::BaseMapper', Class.new)
+
+    stub_const('Test::CategoryMapper', Class.new(Test::BaseMapper))
+    stub_const('Test::CategoryMapper::KEY_MAP', { id: 'ID' }.freeze)
+
+    stub_const('Test::ProductDesignerMapper', Class.new(Test::BaseMapper))
+    stub_const('Test::ProductDesignerMapper::KEY_MAP', { id: 'ID' }.freeze)
+
+    stub_const('Test::ProductMapper', Class.new(Test::BaseMapper))
+    stub_const(
+      'Test::ProductMapper::KEY_MAP',
+      {
+        vat: 'VAT',
+        url: '@url' # TODO: How to handle url attribute?
+      }.freeze
+    )
+    stub_const('Test::ProductMapper::JSON_ENTITY_WRAPPER', 'Product')
+    stub_const('Test::ProductMapper::JSON_COLLECTION_WRAPPER', 'Products')
+
+    stub_const(
+      'Test::Category',
+      Class.new(Fortnox::API::Model::Base) do
         attribute :name, 'strict.string'
         attribute :id, 'strict.string'
       end
+    )
 
-      class ProductDesigner < Fortnox::API::Model::Base
+    stub_const(
+      'Test::ProductDesigner',
+      Class.new(Fortnox::API::Model::Base) do
         attribute :name, 'strict.string'
         attribute :id, 'strict.string'
       end
+    )
 
-      class Product < Fortnox::API::Model::Base
+    stub_const(
+      'Test::Product',
+      Class.new(Fortnox::API::Model::Base) do
         attribute :url, 'strict.string'
         attribute :name, 'strict.string'
         attribute :vat, 'strict.float'
         attribute :categories, Dry::Types['coercible.array'].of(Test::Category)
         attribute :designer, Test::ProductDesigner
       end
-    end
-
-    def register_mapper(mapper_sym, mapper)
-      return if Fortnox::API::Registry.key? mapper_sym
-      Fortnox::API::Registry.register(mapper_sym, mapper)
-    end
+    )
 
-    register_mapper(:category, Test::CategoryMapper)
-    register_mapper(:productdesigner, Test::ProductDesignerMapper)
-    register_mapper(:product, Test::ProductMapper)
+    Fortnox::API::Registry.enable_stubs!
+    add_to_registry(:category, Test::CategoryMapper)
+    add_to_registry(:productdesigner, Test::ProductDesignerMapper)
+    add_to_registry(:product, Test::ProductMapper)
   end
 end

data/spec/fortnox/api/mappers/default_delivery_types_spec.rb

@@ -8,7 +8,7 @@ require 'fortnox/api/mappers/examples/mapper'
 describe Fortnox::API::Mapper::DefaultDeliveryTypes do
   key_map = {}
 
-  it_behaves_like 'mapper', key_map do
+  it_behaves_like 'mapper', key_map, nil, nil do
     let(:mapper) { described_class.new }
   end
 end

data/spec/fortnox/api/mappers/examples/mapper.rb

@@ -12,7 +12,7 @@ shared_examples_for 'mapper' do |key_map, json_entity_wrapper = nil, json_collec
     describe 'key_map' do
       subject { described_class::KEY_MAP }
 
-      it { is_expected.to eq(key_map) }
+      it { expect(subject).to eq(key_map) }
     end
 
     unless json_entity_wrapper.nil?

data/spec/fortnox/api/mappers/unit_spec.rb

@@ -8,7 +8,6 @@ require 'fortnox/api/mappers/examples/mapper'
 
 module Fortnox
   module API
-    # Shhh Rubocop, we don't need a comment here ... Really
     module Mapper
       describe Unit do
         context 'when mapping model' do
@@ -17,13 +16,13 @@ module Fortnox
           let(:model_hash) { { code: 'lbs', description: 'Pounds' } }
 
           describe '#entity_to_hash' do
-            subject { Unit.new.entity_to_hash(model, {}) }
+            subject { described_class.new.entity_to_hash(model, {}) }
 
             it { is_expected.to eq(serialised_model_hash) }
           end
 
           describe '#wrapped_json_hash_to_entity_hash' do
-            subject { Unit.new.wrapped_json_hash_to_entity_hash(serialised_model_hash) }
+            subject { described_class.new.wrapped_json_hash_to_entity_hash(serialised_model_hash) }
 
             it { is_expected.to eq(model_hash) }
           end
@@ -46,7 +45,7 @@ module Fortnox
           end
 
           describe '#wrapped_json_collection_to_entities_hash' do
-            subject { Unit.new.wrapped_json_collection_to_entities_hash(serialised_collection_hash) }
+            subject { described_class.new.wrapped_json_collection_to_entities_hash(serialised_collection_hash) }
 
             it { is_expected.to eq(collection_hash) }
           end

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

@@ -5,8 +5,8 @@ require 'fortnox/api/models/base'
 require 'fortnox/api/types'
 
 describe Fortnox::API::Model::Base do
-  using_test_classes do
-    class Entity < Fortnox::API::Model::Base
+  let(:entity_class) do
+    Class.new(Fortnox::API::Model::Base) do
       attribute :private, Fortnox::API::Types::String.is(:read_only)
       attribute :string, Fortnox::API::Types::Required::String
       attribute :number, Fortnox::API::Types::Nullable::Integer
@@ -16,43 +16,41 @@ describe Fortnox::API::Model::Base do
 
   describe '.new' do
     context 'with basic attribute' do
-      subject { Entity.new(string: 'Test') }
+      subject { entity_class.new(string: 'Test') }
 
-      it { is_expected.to be_a Entity }
+      it { is_expected.to be_a entity_class }
       it { is_expected.to be_new }
       it { is_expected.not_to be_saved }
     end
 
     context 'without required attribute' do
-      subject { -> { Entity.new({}) } }
-
-      it { is_expected.to raise_error Fortnox::API::Exception }
-      it { is_expected.to raise_error Fortnox::API::MissingAttributeError }
-      it { is_expected.to raise_error Fortnox::API::MissingAttributeError, /Missing attribute :string/ }
+      it do
+        expect do
+          entity_class.new({})
+        end.to raise_error Fortnox::API::MissingAttributeError, /Missing attribute :string/
+      end
     end
 
     context 'with invalid attribute value' do
-      subject { -> { Entity.new(string: 'Test', account: 13_337) } }
-
-      it { is_expected.to raise_error Fortnox::API::Exception }
-      it { is_expected.to raise_error Fortnox::API::AttributeError }
-      it { is_expected.to raise_error Fortnox::API::AttributeError, /invalid type for :account/ }
+      it do
+        expect do
+          entity_class.new(string: 'Test', account: 13_337)
+        end.to raise_error Fortnox::API::AttributeError, /invalid type for :account/
+      end
     end
   end
 
   describe '.update' do
-    let(:original) { Entity.new(string: 'Test') }
+    let(:original) { entity_class.new(string: 'Test') }
 
     context 'with new, simple value' do
-      subject { updated_model }
-
-      let(:updated_model) { original.update(string: 'Variant') }
+      subject(:updated_model) { original.update(string: 'Variant') }
 
       it { is_expected.to be_new }
       it { is_expected.not_to be_saved }
 
       it 'returns a new object' do
-        is_expected.not_to eql(original)
+        expect(updated_model).not_to eql(original)
       end
 
       describe 'updated attribute' do
@@ -72,7 +70,7 @@ describe Fortnox::API::Model::Base do
       subject(:updated_model) { original.update(string: 'Test') }
 
       it 'returns the same object' do
-        is_expected.to eql(original)
+        expect(updated_model).to eql(original)
       end
 
       it 'returns a object with the same value' do
@@ -83,9 +81,9 @@ describe Fortnox::API::Model::Base do
       it { is_expected.not_to be_saved }
     end
 
-    context 'when updating' do
+    context 'when updating a saved entity' do
       let(:updated_entity) do
-        saved_entity = Entity.new(string: 'Saved', new: false, unsaved: false)
+        saved_entity = entity_class.new(string: 'Saved', new: false, unsaved: false)
         saved_entity.update(string: 'Updated')
       end
 
@@ -102,5 +100,18 @@ describe Fortnox::API::Model::Base do
         it { is_expected.to eq('Updated') }
       end
     end
+
+    context 'when updating a saved entity with nil values' do
+      subject(:updated_entity) { original.update(number: nil) }
+
+      let(:original) { entity_class.new(string: 'Saved', new: false, unsaved: false) }
+
+      it 'returns the same object' do
+        expect(updated_entity).to eql(original)
+      end
+
+      it { is_expected.not_to be_new }
+      it { is_expected.to be_saved }
+    end
   end
 end

data/spec/fortnox/api/models/unit_spec.rb

@@ -9,9 +9,11 @@ module Fortnox
     module Model
       describe Unit, type: :model do
         context 'when created from empty hash' do
-          subject { -> { described_class.new } }
-
-          it { is_expected.to raise_error(Fortnox::API::MissingAttributeError, /Missing attribute.*:code/) }
+          it {
+            expect do
+              described_class.new
+            end.to raise_error(Fortnox::API::MissingAttributeError, /Missing attribute.*:code/)
+          }
         end
 
         context 'when created from stub' do

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

@@ -10,13 +10,16 @@ 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::Article, order: :defined, integration: true do
+describe Fortnox::API::Repository::Article, 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 }
+
+  # VCR: Requires a Financial Year in Fortnox, otherwise the sales account is not be available.
+  # VCR: Update requires that default accounts exists in the chart of accounts
   include_examples '.save',
                    :description,
                    additional_attrs: { sales_account: 1250 }
@@ -26,18 +29,20 @@ describe Fortnox::API::Repository::Article, order: :defined, integration: true d
                    :ean,
                    '5901234123457'
 
-  # When recording new VCR cassettes, expected matches must be increased
-  include_examples '.all', 29
+  # VCR: expected matches must be increased
+  include_examples '.all', 6
 
-  # When recording new VCR cassettes, expected matches must be increased
+  # VCR: Expected matches must be increased
+  # VCR: Create the searched Articles manually in Fortnox
   include_examples '.find', '1' do
     let(:find_by_hash_failure) { { description: 'Not Found' } }
-    let(:single_param_find_by_hash) { { find_hash: { articlenumber: 1 }, matches: 13 } }
+    let(:single_param_find_by_hash) { { find_hash: { articlenumber: 101 }, matches: 1 } }
 
     let(:multi_param_find_by_hash) do
-      { find_hash: { articlenumber: 1, description: 'Cykelpump' }, matches: 1 }
+      { find_hash: { articlenumber: 101, description: 'Hammer' }, matches: 1 }
     end
   end
 
-  include_examples '.search', :description, 'Testartikel', 2
+  # VCR: Expected mathes must be updated
+  include_examples '.search', :description, 'Test article', 3
 end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fortnox/api'
+require 'fortnox/api/repositories/authentication'
+
+describe Fortnox::API::Repository::Authentication, integration: true do
+  include Helpers::Configuration
+
+  subject(:repository) { described_class.new }
+
+  before { set_api_test_configuration }
+
+  let(:vcr_dir) { 'authentication' }
+
+  let(:valid_response) do
+    VCR.use_cassette("#{vcr_dir}/valid_request") do
+      repository.renew_tokens(
+        refresh_token: ENV.fetch('FORTNOX_API_REFRESH_TOKEN'),
+        client_id: ENV.fetch('FORTNOX_API_CLIENT_ID'),
+        client_secret: ENV.fetch('FORTNOX_API_CLIENT_SECRET')
+      )
+    end
+  end
+
+  describe '#renew_tokens' do
+    context 'with invalid authorization' do
+      let(:request_with_nonsense_credentials) do
+        VCR.use_cassette("#{vcr_dir}/invalid_authorization") do
+          repository.renew_tokens(
+            refresh_token: ENV.fetch('FORTNOX_API_REFRESH_TOKEN'),
+            client_id: 'nonsense_id',
+            client_secret: 'nonsense_secret'
+          )
+        end
+      end
+
+      it 'raises an error' do
+        expect { request_with_nonsense_credentials }.to(
+          raise_error(Fortnox::API::RemoteServerError, /Unauthorized request(.)*Error:(.)*invalid_client/)
+        )
+      end
+    end
+
+    context 'with invalid refresh token' do
+      let(:request_with_invalid_refresh_token) do
+        VCR.use_cassette("#{vcr_dir}/invalid_refresh_token") do
+          repository.renew_tokens(
+            refresh_token: 'invalid_refresh_token',
+            client_id: ENV.fetch('FORTNOX_API_CLIENT_ID'),
+            client_secret: ENV.fetch('FORTNOX_API_CLIENT_SECRET')
+          )
+        end
+      end
+
+      it 'raises an error' do
+        expect { request_with_invalid_refresh_token }.to(
+          raise_error(Fortnox::API::RemoteServerError, /Bad request(.)*Error:(.)*Invalid refresh token/)
+        )
+      end
+    end
+
+    describe 'returned hash' do
+      subject { valid_response }
+
+      it { is_expected.to include(:access_token, :refresh_token, :expires_in, :token_type, :scope) }
+    end
+
+    describe 'access_token' do
+      subject { valid_response[:access_token] }
+
+      it { is_expected.to be_a(String) }
+      it { is_expected.not_to be_empty }
+    end
+
+    describe 'refresh_token' do
+      subject { valid_response[:refresh_token] }
+
+      it { is_expected.to be_a(String) }
+      it { is_expected.not_to be_empty }
+    end
+
+    describe 'expires_in' do
+      subject { valid_response[:expires_in] }
+
+      it { is_expected.to be_a(Integer) }
+    end
+
+    describe 'token_type' do
+      subject { valid_response[:token_type] }
+
+      it { is_expected.to be_a(String) }
+      it { is_expected.not_to be_empty }
+    end
+
+    describe 'scope' do
+      subject { valid_response[:scope] }
+
+      it { is_expected.to be_a(String) }
+      it { is_expected.not_to be_empty }
+    end
+  end
+end