fortnox-api 0.6.3 → 0.7.0

data/lib/fortnox/api/request_handling.rb

@@ -26,7 +26,6 @@ module Fortnox
         end
 
         def execute
-          self.class.set_headers(@headers)
           response = yield(self.class)
           validate_and_parse response
         end

data/lib/fortnox/api/types.rb

@@ -2,6 +2,8 @@
 
 require 'dry-struct'
 require 'dry-types'
+require 'countries'
+require 'fortnox/api/types/shim/country_code_string'
 
 module Dry
   module Types
@@ -24,6 +26,7 @@ module Fortnox
   module API
     module Types
       include Dry::Types.module
+      ISO3166.configure { |config| config.locales = %i[en sv] }
 
       THE_TRUTH = { true => true, 'true' => true, false => false, 'false' => false }.freeze
 
@@ -45,9 +48,22 @@ module Fortnox
                     .constructor(EnumConstructors.default)
 
       CountryCode = Strict::String
-                    .constrained(included_in: CountryCodes.values)
                     .optional
-                    .constructor(EnumConstructors.sized(2))
+                    .constructor do |value|
+                      next value if value.nil? || value == ''
+
+                      # Fortnox only supports Swedish translation of Sweden
+                      next CountryCodeString.new('SE') if value =~ /^s(e$|we|ve)/i
+
+                      country = ::ISO3166::Country[value] ||
+                                ::ISO3166::Country.find_country_by_name(value) ||
+                                ::ISO3166::Country.find_country_by_translated_names(value)
+
+                      raise Dry::Types::ConstraintError.new('value violates constraints', value) if country.nil?
+
+                      CountryCodeString.new(country.alpha2)
+                    end
+
       Currency = Strict::String
                  .constrained(included_in: Currencies.values)
                  .optional
@@ -63,7 +79,7 @@ module Fortnox
                      .constructor(EnumConstructors.default)
 
       Email = Strict::String
-              .constrained(max_size: 1024, format: /^$|\A[\w+-_.]+@[\w+-_.]+\.[a-z]+\z/i)
+              .constrained(max_size: 1024, format: /^$|\A[[[:alnum:]]+-_.]+@[\w+-_.]+\.[a-z]+\z/i)
               .optional
               .constructor { |v| v.to_s.downcase unless v.nil? }
 

data/lib/fortnox/api/types/enums.rb

@@ -35,29 +35,6 @@ module Fortnox
       HouseworkTypes = Types::Strict::String.enum(
         *(CURRENT_HOUSEWORK_TYPES + LEGACY_HOUSEWORK_TYPES)
       )
-      CountryCodes = Types::Strict::String.enum(
-        'AF', 'AX', 'AL', 'DZ', 'AS', 'AD', 'AO', 'AI', 'AQ', 'AG', 'AR', 'AM',
-        'AW', 'AU', 'AT', 'AZ', 'BS', 'BH', 'BD', 'BB', 'BY', 'BE', 'BZ', 'BJ',
-        'BM', 'BT', 'BO', 'BQ', 'BA', 'BW', 'BV', 'BR', 'IO', 'BN', 'BG', 'BF',
-        'BI', 'CV', 'KH', 'CM', 'CA', 'KY', 'CF', 'TD', 'CL', 'CN', 'CX', 'CC',
-        'CO', 'KM', 'CG', 'CD', 'CK', 'CR', 'CI', 'HR', 'CU', 'CW', 'CY', 'CZ',
-        'DK', 'DJ', 'DM', 'DO', 'EC', 'EG', 'SV', 'GQ', 'ER', 'EE', 'ET', 'FK',
-        'FO', 'FJ', 'FI', 'FR', 'GF', 'PF', 'TF', 'GA', 'GM', 'GE', 'DE', 'GH',
-        'GI', 'GR', 'GL', 'GD', 'GP', 'GU', 'GT', 'GG', 'GN', 'GW', 'GY', 'HT',
-        'HM', 'VA', 'HN', 'HK', 'HU', 'IS', 'IN', 'ID', 'IR', 'IQ', 'IE', 'IM',
-        'IL', 'IT', 'JM', 'JP', 'JE', 'JO', 'KZ', 'KE', 'KI', 'KP', 'KR', 'KW',
-        'KG', 'LA', 'LV', 'LB', 'LS', 'LR', 'LY', 'LI', 'LT', 'LU', 'MO', 'MK',
-        'MG', 'MW', 'MY', 'MV', 'ML', 'MT', 'MH', 'MQ', 'MR', 'MU', 'YT', 'MX',
-        'FM', 'MD', 'MC', 'MN', 'ME', 'MS', 'MA', 'MZ', 'MM', 'NA', 'NR', 'NP',
-        'NL', 'NC', 'NZ', 'NI', 'NE', 'NG', 'NU', 'NF', 'MP', 'NO', 'OM', 'PK',
-        'PW', 'PS', 'PA', 'PG', 'PY', 'PE', 'PH', 'PN', 'PL', 'PT', 'PR', 'QA',
-        'RE', 'RO', 'RU', 'RW', 'BL', 'SH', 'KN', 'LC', 'MF', 'PM', 'VC', 'WS',
-        'SM', 'ST', 'SA', 'SN', 'RS', 'SC', 'SL', 'SG', 'SX', 'SK', 'SI', 'SB',
-        'SO', 'ZA', 'GS', 'SS', 'ES', 'LK', 'SD', 'SR', 'SJ', 'SZ', 'SE', 'CH',
-        'SY', 'TW', 'TJ', 'TZ', 'TH', 'TL', 'TG', 'TK', 'TO', 'TT', 'TN', 'TR',
-        'TM', 'TC', 'TV', 'UG', 'UA', 'AE', 'GB', 'US', 'UM', 'UY', 'UZ', 'VU',
-        'VE', 'VN', 'VG', 'VI', 'WF', 'EH', 'YE', 'ZM', 'ZW'
-      )
       Currencies = Types::Strict::String.enum(
         'AED', 'AFN', 'ALL', 'AMD', 'ANG', 'AOA', 'ARS', 'AUD', 'AWG', 'AZN',
         'BAM', 'BBD', 'BDT', 'BGN', 'BHD', 'BIF', 'BMD', 'BND', 'BOB', 'BOV',

data/lib/fortnox/api/types/shim/country_code_string.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Fortnox
+  module API
+    module Types
+      class CountryCodeString < String
+      end
+    end
+  end
+end

data/lib/fortnox/api/types/sized.rb

@@ -21,22 +21,9 @@ module Fortnox
         end
 
         module Float
-          def self.[](low = nil, high = nil, from: nil, to: nil, range: nil)
-            if !from.nil? && !to.nil?
-              # Legacy
-              Types::Strict::Float.constrained(gteq: low, lteq: high).optional.constructor do |value|
-                value.to_f unless value.nil?
-              end
-            elsif range
-              # Legacy
-              Types::Strict::Float.constrained(gteq: low, lteq: high).optional.constructor do |value|
-                value.to_f unless value.nil?
-              end
-            else
-              # Legacy
-              Types::Strict::Float.constrained(gteq: low, lteq: high).optional.constructor do |value|
-                value.to_f unless value.nil?
-              end
+          def self.[](low, high)
+            Types::Strict::Float.constrained(gteq: low, lteq: high).optional.constructor do |value|
+              value.to_f unless value.nil?
             end
           end
         end

data/lib/fortnox/api/version.rb

@@ -2,6 +2,6 @@
 
 module Fortnox
   module API
-    VERSION = '0.6.3'
+    VERSION = '0.7.0'
   end
 end

data/spec/fortnox/api/circular_queue_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fortnox/api/circular_queue'
+
+describe Fortnox::API::CircularQueue do
+  describe 'start index' do
+    context 'when running several times' do
+      let(:test_array) { (0..99).to_a }
+      let(:samples) { Array.new(100) { described_class.new(*test_array).next } }
+
+      subject { Set.new(samples).size }
+
+      # NOTE: This test is not perfect. We are testing that a random generator
+      # with 100 items to choose from does not choose the same item 100 times in a row.
+      # Yes, the possibility is low, but I thought I should just mention it :)
+      it 'does not start with the same item each time' do
+        is_expected.to be > 1
+      end
+    end
+  end
+
+  describe '#next' do
+    context 'when several items in queue' do
+      let(:queue) { described_class.new(1,2,3) }
+      let(:first_round) { Array.new(3) { queue.next } }
+      let(:second_round) { Array.new(3) { queue.next } }
+
+      it 'circulates the items' do
+        first_round
+        expect(first_round[0]).to eq(queue.next)
+      end
+
+      it 'circulates the items in the same order each time' do
+        expect(first_round).to eq(second_round)
+      end
+
+      it 'circulates through given input' do
+        expect(first_round.sort).to eq([1, 2, 3])
+      end
+    end
+
+    context 'when only one item in queue' do
+      let(:queue) { described_class.new(1) }
+
+      it 'circulates the item' do
+        first_item = queue.next
+        expect(first_item).to eq(queue.next)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fortnox/api/mappers/base/canonical_name_sym'
+
+describe Fortnox::API::Mapper::CanonicalNameSym do
+  describe '.canonical_name_sym' do
+    context 'with simple class' do
+      using_test_class do
+        class TestClass
+          extend Fortnox::API::Mapper::CanonicalNameSym
+        end
+      end
+
+      subject { TestClass.canonical_name_sym }
+
+      it { is_expected.to eq(:testclass) }
+    end
+
+    context 'when class included in module' do
+      using_test_class do
+        module Something
+          class Test
+            extend Fortnox::API::Mapper::CanonicalNameSym
+          end
+        end
+      end
+
+      subject { Something::Test.canonical_name_sym }
+
+      it { is_expected.to eq(:test) }
+    end
+  end
+end

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

@@ -35,6 +35,12 @@ describe Fortnox::API::Mapper::Base do
     end
   end
 
+  describe 'integer' do
+    include_examples 'identity mapper', :integer do
+      let(:value) { Fortnox::API::Types::Nullable::Integer[1337] }
+    end
+  end
+
   describe 'float' do
     include_examples 'identity mapper', :float do
       let(:value) { Fortnox::API::Types::Nullable::Float[13.37] }
@@ -111,57 +117,41 @@ describe Fortnox::API::Mapper::Base do
     end
   end
 
-  describe 'AccountNumber' do
-    include_examples 'identity mapper', :account_number do
-      let(:value) { Fortnox::API::Types::AccountNumber[1234] }
-    end
-  end
-
   describe 'CountryCode' do
-    include_examples 'identity mapper', :country_code do
-      let(:value) { Fortnox::API::Types::CountryCode['SE'] }
-    end
-  end
+    subject { mapper.call('GB') }
 
-  describe 'Currency' do
-    include_examples 'identity mapper', :currency do
-      let(:value) { Fortnox::API::Types::Currency['SEK'] }
-    end
-  end
+    let(:mapper) { Fortnox::API::Registry[:countrycodestring] }
 
-  describe 'CustomerType' do
-    include_examples 'identity mapper', :customer_type do
-      let(:value) { Fortnox::API::Types::CustomerType['PRIVATE'] }
-    end
-  end
+    it { is_expected.to eq('United Kingdom') }
 
-  describe 'DiscountType' do
-    include_examples 'identity mapper', :discount_type do
-      let(:value) { Fortnox::API::Types::DiscountType['PERCENT'] }
-    end
-  end
+    describe 'special cases' do
+      context 'with SE' do
+        subject { mapper.call('SE') }
 
-  describe 'Email' do
-    include_examples 'identity mapper', :email do
-      let(:value) { Fortnox::API::Types::Email['email@example.com'] }
-    end
-  end
+        it 'translates code to country name in Swedish' do
+          is_expected.to eq('Sverige')
+        end
+      end
 
-  describe 'HouseworkType' do
-    include_examples 'identity mapper', :housework_type do
-      let(:value) { Fortnox::API::Types::HouseworkType['CONSTRUCTION'] }
-    end
-  end
+      context 'with nil value' do
+        subject { mapper.call(nil) }
 
-  describe 'VATType' do
-    include_examples 'identity mapper', :vat_type do
-      let(:value) { Fortnox::API::Types::VATType['SEVAT'] }
-    end
-  end
+        it { is_expected.to eq(nil) }
+      end
 
-  describe '#canonical_name_sym' do
-    subject { described_class.canonical_name_sym }
+      context 'with empty string' do
+        subject { mapper.call('') }
+
+        it { is_expected.to eq('') }
+      end
 
-    it { is_expected.to eq(described_class.name.split('::').last.downcase.to_sym) }
+      context 'with nonsense' do
+        subject { -> { mapper.call('nonsense') } }
+
+        it 'is not supported (since input is sanitised) and therefore blows up' do
+          raise_error(NoMethodError)
+        end
+      end
+    end
   end
 end

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

@@ -40,7 +40,7 @@ shared_context 'with JSON conversion' do
         attribute :url, 'strict.string'
         attribute :name, 'strict.string'
         attribute :vat, 'strict.float'
-        attribute :categories, Dry::Types['coercible.array'].member(Test::Category)
+        attribute :categories, Dry::Types['coercible.array'].of(Test::Category)
         attribute :designer, Test::ProductDesigner
       end
     end

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

@@ -26,11 +26,13 @@ describe Fortnox::API::Repository::Article, order: :defined, integration: true d
                    :ean,
                    '5901234123457'
 
-  include_examples '.all', 12
+  # When recording new VCR cassettes, expected matches must be increased
+  include_examples '.all', 26
 
+  # When recording new VCR cassettes, expected matches must be increased
   include_examples '.find', '1' do
     let(:find_by_hash_failure) { { description: 'Not Found' } }
-    let(:single_param_find_by_hash) { { find_hash: { articlenumber: 1 }, matches: 3 } }
+    let(:single_param_find_by_hash) { { find_hash: { articlenumber: 1 }, matches: 13 } }
 
     let(:multi_param_find_by_hash) do
       { find_hash: { articlenumber: 1, description: 'Cykelpump' }, matches: 1 }

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

@@ -6,18 +6,25 @@ require 'fortnox/api'
 describe Fortnox::API::Repository::Base do
   using_test_class do
     module Model
-      class Test
+      class RepositoryBaseTest
       end
     end
     module Repository
       class Test < Fortnox::API::Repository::Base
-        MODEL = Model::Test
+        MODEL = Model::RepositoryBaseTest
       end
     end
+  end
+
+  before do
+    Fortnox::API::Registry.register(:repositorybasetest, Model::RepositoryBaseTest)
+  end
 
-    require 'dry/container/stub'
-    Fortnox::API::Registry.enable_stubs!
-    Fortnox::API::Registry.stub(:test, Model::Test)
+  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')
   end
 
   let(:access_token) { '3f08d038-f380-4893-94a0-a08f6e60e67a' }
@@ -36,7 +43,7 @@ describe Fortnox::API::Repository::Base do
 
   describe 'creation' do
     shared_examples_for 'missing configuration' do
-      subject { -> { repository } }
+      subject { -> { Repository::Test.new(token_store: :store1).get('nonsense') } }
 
       let(:error) { Fortnox::API::MissingConfiguration }
 
@@ -45,14 +52,27 @@ describe Fortnox::API::Repository::Base do
 
     context 'without base url' do
       include_examples 'missing configuration' do
-        before { Fortnox::API.configure { |conf| conf.base_url = nil } }
+        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
 
     context 'without client secret' do
       include_examples 'missing configuration' do
-        before { Fortnox::API.configure { |conf| conf.client_secret = nil } }
+        before do
+          Fortnox::API.configure do |config|
+            config.client_secret = nil
+            config.access_tokens = { store1: access_token }
+          end
+        end
+
         let(:message) { 'have to provide your client secret' }
       end
     end

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

@@ -38,5 +38,6 @@ describe Fortnox::API::Repository::Customer, order: :defined, integration: true
     end
   end
 
-  include_examples '.search', :name, 'Test', 23
+  # When recording new VCR casettes, expected matches must be increased
+  include_examples '.search', :name, 'Test', 30
 end

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

@@ -37,7 +37,7 @@ describe Fortnox::API::Repository::Invoice, order: :defined, integration: true d
 
   # It is not possible to delete Invoces. Therefore, expected nr of Orders
   # when running .all will continue to increase (until 100, which is max by default).
-  include_examples '.all', 60
+  include_examples '.all', 97
 
   include_examples '.find', 1 do
     let(:find_by_hash_failure) { { yourreference: 'Not found' } }
@@ -51,7 +51,151 @@ describe Fortnox::API::Repository::Invoice, order: :defined, integration: true d
     end
   end
 
-  include_examples '.search', :customername, 'Test', 3
+  include_examples '.search', :customername, 'Test', 7
 
-  include_examples '.only', :fullypaid, 1
+  include_examples '.only', :fullypaid, 4
+
+  describe 'country attribute' do
+    def new_invoice(country:)
+      described_class::MODEL.new(customer_number: 1, country: country)
+    end
+
+    context 'with valid country' do
+      def save_invoice(country:, vcr_cassette: country)
+        VCR.use_cassette("#{vcr_dir}/save_new_with_country_#{vcr_cassette}") do
+          repository.save(new_invoice(country: country))
+        end
+      end
+
+      it 'accepts English country names' do
+        expect(save_invoice(country: 'Norway').country).to eq('NO')
+      end
+
+      it 'translates Swedish country names to English' do
+        expect(save_invoice(country: 'Norge').country).to eq('NO')
+      end
+
+      it 'skips nil values' do
+        expect(save_invoice(country: nil, vcr_cassette: 'nil').country).to eq('')
+      end
+
+      it 'skips empty string values' do
+        expect(save_invoice(country: '', vcr_cassette: 'empty_string').country).to eq('')
+      end
+
+      describe 'GB' do
+        subject { save_invoice(country: 'GB').country }
+
+        it { is_expected.to eq('GB') }
+      end
+
+      describe 'KR' do
+        subject { save_invoice(country: 'KR').country }
+
+        it { is_expected.to eq('KR') }
+      end
+
+      describe 'VA' do
+        subject { save_invoice(country: 'VA').country }
+
+        it { is_expected.to eq('VA') }
+      end
+
+      describe 'VI' do
+        subject { save_invoice(country: 'VI').country }
+
+        it { is_expected.to eq('VI') }
+      end
+
+      describe 'special cases Sverige' do
+        subject { save_invoice(country: 'Sverige').country }
+
+        it { is_expected.to eq('SE') }
+      end
+    end
+  end
+
+  describe 'resetting values in Fortnox' do
+    context 'with String values' do
+      def new_invoice(comments:)
+        described_class::MODEL.new(customer_number: 1, comments: comments)
+      end
+
+      let(:persisted_invoice) do
+        VCR.use_cassette("#{vcr_dir}/save_new_with_comments") do
+          repository.save(new_invoice(comments: 'A comment to be reset'))
+        end
+      end
+
+      before { persisted_invoice }
+
+      context 'by setting value to nil' do
+        let(:updated_persisted_invoice) do
+          VCR.use_cassette("#{vcr_dir}/save_old_with_nil_comments") do
+            repository.save(persisted_invoice.update(comments: nil))
+          end
+        end
+
+        subject { updated_persisted_invoice.comments }
+
+        pending { is_expected.to eq(nil) }
+      end
+
+      context 'by setting value to empty string' do
+        let(:updated_persisted_invoice) do
+          VCR.use_cassette("#{vcr_dir}/save_old_with_empty_comments") do
+            repository.save(persisted_invoice.update(comments: ''))
+          end
+        end
+
+        subject { updated_persisted_invoice.comments }
+
+        it 'does not reset the value' do
+          is_expected.to eq('A comment to be reset')
+        end
+      end
+    end
+
+    context 'with other values' do
+      def new_invoice(country:)
+        described_class::MODEL.new(customer_number: 1, country: country)
+      end
+
+      let(:persisted_invoice) do
+        VCR.use_cassette("#{vcr_dir}/save_new_with_country") do
+          repository.save(new_invoice(country: 'Sverige'))
+        end
+      end
+
+      before { persisted_invoice }
+
+      context 'by setting value to nil' do
+        let(:updated_persisted_invoice) do
+          # TODO: This VCR cassette needs to be re-recorded again
+          # when the we fix #172.
+          VCR.use_cassette("#{vcr_dir}/save_old_with_nil_country") do
+            repository.save(persisted_invoice.update(country: nil))
+          end
+        end
+
+        subject { updated_persisted_invoice.country }
+
+        pending { is_expected.to eq(nil) }
+      end
+
+      context 'by setting value to empty string' do
+        let(:updated_persisted_invoice) do
+          VCR.use_cassette("#{vcr_dir}/save_old_with_empty_country") do
+            repository.save(persisted_invoice.update(country: ''))
+          end
+        end
+
+        subject { updated_persisted_invoice.country }
+
+        it 'does not reset the country' do
+          is_expected.to eq('SE')
+        end
+      end
+    end
+  end
 end