fortnox-api 0.5.2 → 0.6.0

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

@@ -1,11 +1,13 @@
+# 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 )
+    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 )
+      def initialize(attribute, valid_value, invalid_value, default_value)
         @attribute = attribute
         @valid_value = valid_value
         @invalid_value = invalid_value
@@ -13,40 +15,40 @@ module Matchers
         @failure_description = ''
       end
 
-      def matches?( klass )
+      def matches?(klass)
         @klass = klass
 
         accepts_nil? && accepts_valid_value? && defaults_invalid_value?
       end
 
       def description
-        "have nullable attribute #{ @attribute.inspect }"
+        "have nullable attribute #{@attribute.inspect}"
       end
 
       def failure_message
-        "Expected class to have nullable attribute #{ @attribute.inspect }" << @failure_description
+        "Expected class to have nullable attribute #{@attribute.inspect}" << @failure_description
       end
 
       private
 
-        def accepts_nil?
-          @klass.new(@attribute => nil)
-        end
+      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 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
+      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
+        @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,15 +1,17 @@
+# frozen_string_literal: true
+
 module Matchers
   module Type
-    def have_nullable_string( attribute, valid_hash = {} )
-      HaveNullableStringMatcher.new( attribute, valid_hash )
+    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' )
+      def initialize(attribute, valid_hash)
+        super(attribute, valid_hash, 'nullable string')
       end
 
-      def matches?( klass )
+      def matches?(klass)
         super
 
         accepts_nil? && accepts_string? && rejects_non_string?
@@ -17,33 +19,29 @@ module Matchers
 
       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
+      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}"
+        return true if error.message.include?(expected_message)
+
+        fail_message = "Expected error message to include #{expected_message.inspect}, "\
+                       "but was #{error.message.inspect}"
+        raise(fail_message)
+      end
+    end
   end
 end

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

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Matchers
   module Type
-    def have_sized_float( attribute, min_value, max_value, valid_hash = {} )
+    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 )
+      NumericMatcher.new(attribute, valid_hash, 'sized float', options)
     end
   end
 end

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

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Matchers
   module Type
-    def have_sized_integer( attribute, min_value, max_value, valid_hash = {} )
+    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 )
+      NumericMatcher.new(attribute, valid_hash, 'sized integer', options)
     end
   end
 end

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

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module Matchers
   module Type
-    def have_sized_string( attribute, max_size, valid_hash = {} )
-      HaveSizedStringMatcher.new( attribute, max_size, valid_hash )
+    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' )
+      def initialize(attribute, max_size, valid_hash)
+        super(attribute, valid_hash, 'sized string')
         @max_size = max_size
       end
 
-      def matches?( klass )
+      def matches?(klass)
         @klass = klass
 
         accepts_max_size? && rejects_too_long_string?
@@ -18,18 +20,17 @@ module Matchers
 
       private
 
-        def accepts_max_size?
-          @klass.new( @valid_hash.merge( @attribute => 'a' * @max_size ) )
-        end
+      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
+      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,7 +1,9 @@
+# frozen_string_literal: true
+
 module Matchers
   module Type
-    def have_vat_type( attribute, valid_hash = {} )
-      EnumMatcher.new( attribute, valid_hash, 'VATType', 'VATTypes' )
+    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,15 +1,17 @@
+# 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 )
+      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 )
+      def matches?(klass)
         super
 
         rejects_too_small_value? &&
@@ -20,31 +22,31 @@ module Matchers
 
       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 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_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 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_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
+      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,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fortnox/api'
 
 module Matchers
@@ -9,12 +11,12 @@ module Matchers
     class RequireAttributeMatcher
       EXCEPTION = Fortnox::API::MissingAttributeError
 
-      def initialize( attribute, valid_hash )
+      def initialize(attribute, valid_hash)
         @attribute = attribute
-        @invalid_hash = valid_hash.dup.tap{ |hash| hash.delete( attribute ) }
+        @invalid_hash = valid_hash.dup.tap { |hash| hash.delete(attribute) }
       end
 
-      def matches?( klass )
+      def matches?(klass)
         @klass = klass
 
         raise_error && includes_error_message
@@ -26,44 +28,41 @@ module Matchers
       end
 
       def description
-        "require attribute #{ @attribute.inspect }"
+        "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
+      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
+        return true if error.message.include? expected_error_message
+
+        @wrong_error_message = error.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

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

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