fortnox-api 0.9.2 → 1.0.0.rc2

data/spec/fortnox/api_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'fortnox/api'
-
-describe Fortnox::API do
-  before { stub_const('Fortnox::API::TestBase', Class.new) }
-
-  describe 'configuration defaults' do
-    subject(:config_value) { described_class.config[config_key] }
-
-    before { Fortnox::API::TestBase.new }
-
-    describe 'base_url' do
-      let(:config_key) { :base_url }
-
-      it { is_expected.to eq 'https://api.fortnox.se/3/' }
-    end
-
-    describe 'token_url' do
-      let(:config_key) { :token_url }
-
-      it { is_expected.to eq 'https://apps.fortnox.se/oauth-v1/token' }
-    end
-
-    describe 'logger' do
-      let(:config_key) { :logger }
-
-      it { is_expected.to be_a Logger }
-
-      describe 'level' do
-        subject { config_value.level }
-
-        it { is_expected.to be Logger::WARN }
-      end
-    end
-  end
-
-  describe 'readers for' do
-    describe 'debugging' do
-      subject(:debugging) { described_class.debugging }
-
-      it 'is available' do
-        expect(debugging).to be false
-      end
-    end
-
-    describe 'logger' do
-      subject(:logger) { described_class.logger }
-
-      it 'is available' do
-        expect(logger).to be_a Logger
-      end
-    end
-  end
-
-  describe '#access_token' do
-    context 'when token is set' do
-      before { described_class.access_token = 'an_access_token' }
-
-      it 'returns the token' do
-        expect(described_class.access_token).to eq('an_access_token')
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-ENV['RUBY_ENV'] = 'test'
-
-require 'simplecov'
-
-SimpleCov.start
-
-require 'rspec/collection_matchers'
-require 'webmock/rspec'
-require 'pry'
-require 'support/matchers'
-require 'support/helpers'
-require 'support/vcr_setup'
-
-RSpec.configure do |config|
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
-  config.extend Helpers # Allow access to helpers in describe and context blocks
-  config.include Helpers # Allow access to helpers in it and let blocks
-
-  config.include Matchers::Type, type: :type
-
-  config.order = 'random'
-
-  WebMock.disable_net_connect!(allow: 'codeclimate.com')
-
-  # Reset configuration after each test run
-  config.after do
-    Fortnox::API::DEFAULT_CONFIGURATION.each do |key, value|
-      Fortnox::API.config.send("#{key}=", value)
-    end
-  end
-end

data/spec/support/helpers/configuration_helper.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'dotenv'
-require 'jwt'
-
-DOTENV_FILE_NAME = '.env.test'
-Dotenv.load(DOTENV_FILE_NAME)
-
-DEBUG = ENV.fetch('DEBUG', false) == true
-
-module Helpers
-  module Configuration
-    def set_api_test_configuration # rubocop:disable Metrics/MethodLength
-      Fortnox::API.configure do |config|
-        config.debugging = DEBUG
-
-        if DEBUG
-          config.logger = lambda {
-            logger = Logger.new($stdout)
-            logger.level = Logger::DEBUG
-            return logger
-          }.call
-        end
-      end
-
-      Fortnox::API.access_token = ENV.fetch('FORTNOX_API_ACCESS_TOKEN')
-    end
-
-    def add_to_registry(symbol, klass)
-      unless Fortnox::API::Registry.key? symbol
-        # Only register the key once...
-        Fortnox::API::Registry.register(symbol) { klass }
-      end
-
-      # ... but stub the value each test run
-      Fortnox::API::Registry.stub(symbol, klass)
-    end
-  end
-end

data/spec/support/helpers/repository_helper.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Helpers
-  module Repositories
-    # Returns directory for VCR.
-    def vcr_dir
-      described_class::MAPPER::JSON_COLLECTION_WRAPPER.downcase
-    end
-  end
-end

data/spec/support/helpers.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-Dir[File.expand_path('spec/support/helpers/*.rb')].sort.each { |file| require file }

data/spec/support/matchers/type/attribute_matcher.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    class AttributeMatcher
-      def initialize(attribute, valid_hash, attribute_type)
-        @attribute = attribute
-        @valid_hash = valid_hash.dup
-        @attribute_type = attribute_type
-        @errors = ''
-      end
-
-      def matches?(klass)
-        @klass = klass
-      end
-
-      def description
-        "have #{@attribute_type} attribute #{@attribute.inspect}"
-      end
-
-      def failure_message
-        "Expected class to have attribute #{@attribute.inspect} defined as #{@attribute_type}, " \
-        "but got following errors:
-        #{@errors}"
-      end
-
-      protected
-
-      def expect_error(msg)
-        yield
-
-        @errors = @errors += msg
-        false # Fail test since expected error not thrown
-      rescue Dry::Struct::Error
-        # TODO: check if error message is correct
-        true
-      end
-    end
-  end
-end

data/spec/support/matchers/type/enum_matcher.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    class EnumMatcher < TypeMatcher
-      def initialize(attribute, valid_hash, enum_type, enum_types, nonsense_value: 'NONSENSE')
-        valid_value = Fortnox::API::Types.const_get(enum_types).values.first
-
-        super(attribute, valid_hash, enum_type, valid_value, nonsense_value)
-
-        @enum_type = Fortnox::API::Types.const_get(enum_type)
-        @expected_error = "Exception missing for nonsense value #{@invalid_value.inspect}"
-      end
-
-      private
-
-      def expected_type?
-        @actual_type = @klass.schema.keys.find { |x| x.name == @attribute }&.type
-        @actual_type == @enum_type
-      end
-    end
-  end
-end

data/spec/support/matchers/type/have_account_number_matcher.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_account_number(attribute, valid_hash = {})
-      HaveAccountNumberMatcher.new(attribute, valid_hash)
-    end
-
-    class HaveAccountNumberMatcher < TypeMatcher
-      def initialize(attribute, valid_hash)
-        super(attribute, valid_hash, 'account number', 1000, -1)
-        @expected_error = "Exception missing for invalid value #{@invalid_value.inspect}"
-      end
-
-      private
-
-      def expected_type?
-        @actual_type = @klass.schema.keys.find { |x| x.name == @attribute }&.type
-        @actual_type == Fortnox::API::Types::AccountNumber
-      end
-    end
-  end
-end

data/spec/support/matchers/type/have_currency_matcher.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_currency(attribute, valid_hash = {})
-      EnumMatcher.new(attribute, valid_hash, 'Currency', 'Currencies')
-    end
-  end
-end

data/spec/support/matchers/type/have_customer_type_matcher.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_customer_type(attribute, valid_hash = {})
-      HaveCustomerTypeMatcher.new(attribute, valid_hash)
-    end
-
-    class HaveCustomerTypeMatcher < EnumMatcher
-      def initialize(attribute, valid_hash)
-        super(attribute, valid_hash, 'CustomerType', 'CustomerTypes')
-      end
-    end
-  end
-end

data/spec/support/matchers/type/have_default_delivery_type_matcher.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_default_delivery_type(attribute, valid_hash = {})
-      EnumMatcher.new(attribute, valid_hash, 'DefaultDeliveryType', 'DefaultDeliveryTypeValues')
-    end
-  end
-end

data/spec/support/matchers/type/have_discount_type_matcher.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_discount_type(attribute, valid_hash = {})
-      EnumMatcher.new(attribute, valid_hash, 'DiscountType', 'DiscountTypes')
-    end
-  end
-end

data/spec/support/matchers/type/have_email_matcher.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_email(attribute, valid_hash = {})
-      HaveEmailMatcher.new(attribute, valid_hash)
-    end
-
-    class HaveEmailMatcher < TypeMatcher
-      def initialize(attribute, valid_hash)
-        super(attribute, valid_hash, 'email', 'valid@email.com', 'invalid@email_without_top_domain')
-        @expected_error = "Exception missing for invalid value #{@invalid_value.inspect}"
-        @expected_type = Fortnox::API::Types::Email
-      end
-
-      private
-
-      def expected_type?
-        @actual_type = @klass.schema.keys.find { |x| x.name == @attribute }&.type
-        @actual_type == Fortnox::API::Types::Email
-      end
-    end
-  end
-end

data/spec/support/matchers/type/have_housework_type_matcher.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_housework_type(attribute, valid_hash = {})
-      EnumMatcher.new(attribute, valid_hash, 'HouseworkType', 'HouseworkTypes')
-    end
-  end
-end

data/spec/support/matchers/type/have_nullable_date_matcher.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_nullable_date(attribute, valid_value, invalid_value)
-      HaveNullableDateMatcher.new(attribute, valid_value, invalid_value)
-    end
-
-    class HaveNullableDateMatcher < HaveNullableMatcher
-      def initialize(attribute, valid_value, invalid_value)
-        @attribute = attribute
-        @valid_value = valid_value
-        @invalid_value = invalid_value
-        @expected_error = Fortnox::API::AttributeError
-        @expected_error_message = 'invalid date'
-        @failure_description = ''
-
-        super(attribute, valid_value, invalid_value, nil)
-      end
-
-      def matches?(klass)
-        @klass = klass
-
-        accepts_nil? && accepts_valid_value? && rejects_invalid_value?
-      end
-
-      def description
-        "have nullable attribute #{@attribute.inspect}"
-      end
-
-      def failure_message
-        "Expected class to have nullable attribute #{@attribute.inspect}" << @failure_description
-      end
-
-      private
-
-      def accepts_nil?
-        @klass.new(@attribute => nil)
-      end
-
-      def accepts_valid_value?
-        model = @klass.new(@attribute => @valid_value)
-        model.send(@attribute) == @valid_value
-      end
-
-      def rejects_invalid_value?
-        @klass.new(@attribute => @invalid_value)
-
-        @failure_description << " (Expected #{@expected_error}, but got none)"
-        false
-      rescue @expected_error => exception
-        return true if exception.message == @expected_error_message
-
-        fail_message = "Expected error message to include #{@expected_error_message.inspect}, " \
-                       "but was #{exception.message.inspect}"
-        raise(fail_message)
-      end
-    end
-  end
-end

data/spec/support/matchers/type/have_nullable_matcher.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_nullable(attribute, valid_value, invalid_value, default_value)
-      HaveNullableMatcher.new(attribute, valid_value, invalid_value, default_value)
-    end
-
-    class HaveNullableMatcher
-      def initialize(attribute, valid_value, invalid_value, default_value)
-        @attribute = attribute
-        @valid_value = valid_value
-        @invalid_value = invalid_value
-        @default_value = default_value
-        @failure_description = ''
-      end
-
-      def matches?(klass)
-        @klass = klass
-
-        accepts_nil? && accepts_valid_value? && defaults_invalid_value?
-      end
-
-      def description
-        "have nullable attribute #{@attribute.inspect}"
-      end
-
-      def failure_message
-        "Expected class to have nullable attribute #{@attribute.inspect}" << @failure_description
-      end
-
-      private
-
-      def accepts_nil?
-        @klass.new(@attribute => nil)
-      end
-
-      def accepts_valid_value?
-        model = @klass.new(@attribute => @valid_value)
-        model.send(@attribute) == @valid_value
-      end
-
-      def defaults_invalid_value?
-        model = @klass.new(@attribute => @invalid_value)
-        value = model.send(@attribute)
-        return true if value == @default_value
-
-        @failure_description << " (Expected #{@invalid_value.inspect} to default to " \
-                                "#{@default_value.inspect}), but got #{value.inspect}"
-        false
-      end
-    end
-  end
-end

data/spec/support/matchers/type/have_nullable_string_matcher.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_nullable_string(attribute, valid_hash = {})
-      HaveNullableStringMatcher.new(attribute, valid_hash)
-    end
-
-    class HaveNullableStringMatcher < AttributeMatcher
-      def initialize(attribute, valid_hash)
-        super(attribute, valid_hash, 'nullable string')
-      end
-
-      def matches?(klass)
-        super
-
-        accepts_nil? && accepts_string? && rejects_non_string?
-      end
-
-      private
-
-      def accepts_nil?
-        model = @klass.new(@valid_hash.merge(@attribute => nil))
-        model.send(@attribute).nil?
-      end
-
-      def accepts_string?
-        valid_string = 'A string'
-        model = @klass.new(@valid_hash.merge(@attribute => valid_string))
-        model.send(@attribute) == 'A string'
-      end
-
-      def rejects_non_string?
-        non_string = 10.0
-        @klass.new(@valid_hash.merge(@attribute => non_string))
-      rescue Fortnox::API::AttributeError => exception
-        expected_message = "#{non_string.inspect} (#{non_string.class}) " \
-                           "has invalid type for #{@attribute.inspect}"
-        return true if exception.message.include?(expected_message)
-
-        fail_message = "Expected error message to include #{expected_message.inspect}, " \
-                       "but was #{exception.message.inspect}"
-        raise(fail_message)
-      end
-    end
-  end
-end

data/spec/support/matchers/type/have_sized_float_matcher.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_sized_float(attribute, min_value, max_value, valid_hash = {})
-      options = { min_value: min_value, max_value: max_value, step: 0.1 }
-      NumericMatcher.new(attribute, valid_hash, 'sized float', options)
-    end
-  end
-end

data/spec/support/matchers/type/have_sized_integer_matcher.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_sized_integer(attribute, min_value, max_value, valid_hash = {})
-      options = { min_value: min_value, max_value: max_value, step: 1 }
-      NumericMatcher.new(attribute, valid_hash, 'sized integer', options)
-    end
-  end
-end

data/spec/support/matchers/type/have_sized_string_matcher.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_sized_string(attribute, max_size, valid_hash = {})
-      HaveSizedStringMatcher.new(attribute, max_size, valid_hash)
-    end
-
-    class HaveSizedStringMatcher < AttributeMatcher
-      def initialize(attribute, max_size, valid_hash)
-        super(attribute, valid_hash, 'sized string')
-        @max_size = max_size
-      end
-
-      def matches?(klass)
-        @klass = klass
-
-        accepts_max_size? && rejects_too_long_string?
-      end
-
-      private
-
-      def accepts_max_size?
-        @klass.new(@valid_hash.merge(@attribute => 'a' * @max_size))
-      end
-
-      def rejects_too_long_string?
-        too_long = @max_size + 1
-        too_long_string = 'a' * too_long
-        expect_error("Exception missing for too long string (#{too_long} characters)") do
-          @klass.new(@valid_hash.merge(@attribute => too_long_string))
-        end
-      end
-    end
-  end
-end

data/spec/support/matchers/type/have_vat_type_matcher.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    def have_vat_type(attribute, valid_hash = {})
-      EnumMatcher.new(attribute, valid_hash, 'VATType', 'VATTypes')
-    end
-  end
-end

data/spec/support/matchers/type/numeric_matcher.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Matchers
-  module Type
-    class NumericMatcher < AttributeMatcher
-      def initialize(attribute, valid_hash, attr_type, options)
-        super(attribute, valid_hash, attr_type)
-
-        @min_value = options[:min_value]
-        @max_value = options[:max_value]
-        @step = options[:step]
-      end
-
-      def matches?(klass)
-        super
-
-        rejects_too_small_value? &&
-          accepts_min_value? &&
-          accepts_max_value? &&
-          rejects_too_big_value?
-      end
-
-      private
-
-      def rejects_too_small_value?
-        too_small_value = @min_value - @step
-        expected_error_message = "Exception missing for too small value (#{too_small_value})"
-        rejects_value?(too_small_value, expected_error_message)
-      end
-
-      def accepts_min_value?
-        @klass.new(@valid_hash.merge(@attribute => @min_value))
-      end
-
-      def accepts_max_value?
-        @klass.new(@valid_hash.merge(@attribute => @max_value))
-      end
-
-      def rejects_too_big_value?
-        too_big_value = @max_value + @step
-        expected_error_message = "Exception missing for too big value (#{too_big_value})"
-        rejects_value?(too_big_value, expected_error_message)
-      end
-
-      def rejects_value?(value, expected_error_message)
-        expect_error(expected_error_message) do
-          @klass.new(@valid_hash.merge(@attribute => value))
-        end
-      end
-    end
-  end
-end

data/spec/support/matchers/type/require_attribute_matcher.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'fortnox/api'
-
-module Matchers
-  module Type
-    def require_attribute(attribute, valid_hash = {})
-      RequireAttributeMatcher.new(attribute, valid_hash)
-    end
-
-    class RequireAttributeMatcher
-      EXCEPTION = Fortnox::API::MissingAttributeError
-
-      def initialize(attribute, valid_hash)
-        @attribute = attribute
-        @invalid_hash = valid_hash.dup.tap { |hash| hash.delete(attribute) }
-      end
-
-      def matches?(klass)
-        @klass = klass
-
-        raise_error && includes_error_message
-      end
-
-      def failure_message
-        return no_exception_failure_message unless raise_error
-        return wrong_error_message unless includes_error_message
-      end
-
-      def description
-        "require attribute #{@attribute.inspect}"
-      end
-
-      private
-
-      def raise_error
-        @klass.new(@invalid_hash)
-
-        false # Fail test since expected error is not thrown
-      rescue EXCEPTION
-        true
-      end
-
-      def includes_error_message
-        @klass.new(@invalid_hash)
-      rescue EXCEPTION => exception
-        return true if exception.message.include? expected_error_message
-
-        @wrong_error_message = exception.message
-        false
-      end
-
-      def expected_error_message
-        @attribute.to_s
-      end
-
-      def no_exception_failure_message
-        "Expected class to raise #{EXCEPTION} " \
-          "when attribute #{@attribute.inspect} is missing."
-      end
-
-      def wrong_error_message
-        "Expected exception to equal #{expected_error_message.inspect}. " \
-          "Message was #{@wrong_error_message.inspect}."
-      end
-    end
-  end
-end