fortnox-api 0.1.0 → 0.2.0

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

@@ -0,0 +1,13 @@
+module Matchers
+  module Type
+    def have_country_code( attribute, valid_hash = {} )
+      HaveCountryCodeMatcher.new( attribute, valid_hash )
+    end
+
+    class HaveCountryCodeMatcher < EnumMatcher
+      def initialize( attribute, valid_hash )
+        super( attribute, valid_hash, 'CountryCode', 'CountryCodes', nonsense_value: 'XX'.freeze )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,22 @@
+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[@attribute]
+          @actual_type == Fortnox::API::Types::Email
+        end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Matchers
+  module Type
+    def have_house_work_type( attribute, valid_hash = {} )
+      EnumMatcher.new( attribute, valid_hash, 'HouseWorkType', 'HouseWorkTypes' )
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+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 = ArgumentError
+        @expected_error_message = 'invalid date'
+        @failure_description = ''
+      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)"
+          return false
+        rescue @expected_error => error
+          if error.message == @expected_error_message
+            return true
+          else
+            fail_message = "Expected error message to include #{ expected_message.inspect }, "\
+                           "but was #{ error.message.inspect }"
+            fail(fail_message)
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,49 @@
+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::InvalidAttributeValueError => error
+          expected_message = "#{ non_string.inspect } (#{ non_string.class }) "\
+                             "has invalid type for #{ @attribute.inspect }"
+          if error.message.include?(expected_message)
+            return true
+          else
+            fail_message = "Expected error message to include #{ expected_message.inspect }, "\
+                           "but was #{ error.message.inspect }"
+            fail(fail_message)
+          end
+
+        end
+    end
+
+  end
+end

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,69 @@
+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 => error
+          if error.message.include? expected_error_message
+            return true
+          else
+            @wrong_error_message = error.message
+            return false
+          end
+        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

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

@@ -0,0 +1,38 @@
+module Matchers
+  module Type
+    class TypeMatcher < AttributeMatcher
+      def initialize( attr, valid_hash, attr_name, valid_value, invalid_value )
+        super( attr, valid_hash, attr_name )
+
+        @valid_value = valid_value
+        @invalid_value = invalid_value
+      end
+
+      def matches?( klass )
+        super
+
+        correct_type? && rejects_invalid_value? && accepts_valid_value?
+      end
+
+      private
+
+        def correct_type?
+          return true if expected_type?
+
+          @errors << "Attribute #{ @attribute.inspect } was expected to be of type #{ @attribute_type }, but was #{ @actual_type }"
+          return false
+        end
+
+        def accepts_valid_value?
+          @klass.new( @valid_hash.merge( @attribute => @valid_value ) )
+        end
+
+        def rejects_invalid_value?
+          expect_error(@expected_error) do
+            @klass.new( @valid_hash.merge( @attribute => @invalid_value ) )
+          end
+        end
+
+    end
+  end
+end