schemacop 3.0.39 → 3.1.1

data/test/unit/schemacop/v3/string_node_test.rb

@@ -323,6 +323,10 @@ module Schemacop
           error '/', 'String does not match format "integer".'
         end
 
+        assert_validation "32\ntest" do
+          error '/', 'String does not match format "integer".'
+        end
+
         assert_cast(nil, nil)
         assert_cast('2234', 2234)
         assert_cast('-1', -1)
@@ -516,9 +520,11 @@ module Schemacop
       end
 
       def test_format_custom
+        formatters_was = Schemacop.string_formatters.dup
+
         Schemacop.register_string_formatter(
           :integer_tuple_list,
-          pattern: /^(-?[0-9]+):(-?[0-9]+)(,(-?[0-9]+):(-?[0-9]+))*$/,
+          pattern: /\A(-?[0-9]+):(-?[0-9]+)(,(-?[0-9]+):(-?[0-9]+))*\z/,
           handler: proc do |value|
             value.split(',').map { |t| t.split(':').map(&:to_i) }
           end
@@ -539,8 +545,55 @@ module Schemacop
           error '/', 'String does not match format "integer-tuple-list".'
         end
 
+        assert_validation "1:5\nsd sfdij soidf" do
+          error '/', 'String does not match format "integer-tuple-list".'
+        end
+
         assert_cast nil, nil
         assert_cast '1:2,3:4,5:-6', [[1, 2], [3, 4], [5, -6]]
+      ensure
+        Schemacop.string_formatters = formatters_was
+      end
+
+      # A format pattern must be anchored with \A and \z: ^ and $ match the
+      # start and the end of any line, so a multi-line string would pass the
+      # validation and be handed to the cast handler.
+      def test_format_multiline
+        values = {
+          date:         '2020-01-13',
+          date_time:    '2018-11-13T20:20:39Z',
+          time:         '20:30:39Z',
+          email:        'support@example.com',
+          mailbox:      '<support@example.com>',
+          boolean:      'true',
+          integer:      '23425',
+          number:       '2.34',
+          integer_list: '1,2,3',
+          ipv4:         '192.168.0.1',
+          ipv4_cidr:    '192.168.0.1/24',
+          ipv6:         '2001:db8::1'
+        }
+
+        assert_equal Schemacop.string_formatters.reject { |_, f| f[:pattern].nil? }.keys.sort,
+                     values.keys.map { |format| format.to_s.dasherize.to_sym }.sort,
+                     'Every format with a pattern must be covered here'
+
+        values.each do |format, value|
+          name = format.to_s.dasherize.to_sym
+
+          schema :string, format: format
+
+          assert_validation value
+
+          ["#{value}\nfoo", "foo\n#{value}", "#{value}\n"].each do |multiline|
+            refute Schemacop.string_formatters[name][:pattern].match?(multiline),
+                   "Format #{name} matches the multi-line value #{multiline.inspect}"
+
+            assert_validation multiline do
+              error '/', "String does not match format #{name.to_s.inspect}."
+            end
+          end
+        end
       end
 
       def test_enum
@@ -653,7 +706,7 @@ module Schemacop
         end
 
         assert_raises_with_message Exceptions::InvalidSchemaError,
-                                   'Option "pattern" can\'t be parsed: end pattern '\
+                                   'Option "pattern" can\'t be parsed: end pattern ' \
                                    'with unmatched parenthesis: /(abcde/.' do
           schema :string, pattern: '(abcde'
         end
@@ -750,6 +803,201 @@ module Schemacop
         assert_cast("\t", "\t")
       end
 
+      def test_encoding_single
+        schema :string, encoding: 'UTF-8'
+
+        assert_validation 'Hello World'
+        assert_validation ''
+
+        assert_validation 'Hello World'.encode('ASCII') do
+          error '/', 'String has encoding "US-ASCII" but must be "UTF-8".'
+        end
+      end
+
+      def test_encoding_multiple
+        schema :string, encoding: %w[UTF-8 US-ASCII]
+
+        assert_validation 'Hello World'
+        assert_validation 'Hello World'.encode('ASCII')
+
+        assert_validation 'Hello World'.encode('ISO-8859-1') do
+          error '/', 'String has encoding "ISO-8859-1" but must be "UTF-8" or "US-ASCII".'
+        end
+      end
+
+      def test_encoding_with_nil
+        schema :string, encoding: 'UTF-8'
+
+        assert_validation nil
+      end
+
+      def test_encoding_invalid_bytes
+        schema :string, encoding: 'UTF-8'
+
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_without_specific_encoding
+        schema :string
+
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_us_ascii
+        schema :string
+
+        assert_validation invalid_string('US-ASCII') do
+          error '/', 'String has invalid "US-ASCII" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_and_encoding_mismatch
+        schema :string, encoding: 'UTF-8'
+
+        assert_validation invalid_string('US-ASCII') do
+          error '/', 'String has encoding "US-ASCII" but must be "UTF-8".'
+          error '/', 'String has invalid "US-ASCII" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_format
+        schema :string, format: :integer
+
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_format_options
+        schema :string, format: :integer, format_options: { minimum: 5 }
+
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_format_without_pattern
+        schema :string, format: :symbol
+
+        assert_validation :foo.to_s
+
+        # The symbol formatter has no pattern to fail on, and its handler calls
+        # "to_sym", which raises on an invalid byte sequence.
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_incompatible_with_pattern
+        schema :string, pattern: /^ü+$/
+
+        assert_validation 'üü'
+        assert_validation 'üü'.encode('ISO-8859-1') do
+          error '/', 'String does not match pattern "^ü+$".'
+        end
+      end
+
+      def test_encoding_incompatible_with_format
+        schema :string, format: :integer
+
+        assert_validation '42'
+
+        # UTF-16 is a dummy encoding and cannot be matched against a pattern in
+        # any other encoding, so the string does not match, valid as it looks.
+        assert_validation '42'.encode('UTF-16') do
+          error '/', 'String does not match format "integer".'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_pattern
+        schema :string, pattern: /\Aabc.*\z/
+
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_allow_blank_false
+        schema :string, allow_blank: false
+
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_incompatible_with_allow_blank_false
+        schema :string, allow_blank: false
+
+        assert_validation '42'.encode('UTF-16')
+        assert_validation ''.encode('UTF-16') do
+          error '/', 'String is blank but must not be blank!'
+        end
+      end
+
+      def test_encoding_binary_has_no_invalid_bytes
+        schema :string
+
+        # Every byte sequence is valid in ASCII-8BIT.
+        assert_validation invalid_string('ASCII-8BIT')
+      end
+
+      def test_encoding_invalid_bytes_with_length
+        schema :string, min_length: 20, max_length: 30
+
+        # The length checks do not decode the string, so they are still
+        # reported.
+        assert_validation invalid_string do
+          error '/', 'String is 7 characters long but must be at least 20.'
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_incompatible_with_length
+        schema :string, max_length: 2
+
+        assert_validation '42'
+
+        # A dummy encoding has no characters, so "size" counts bytes.
+        assert_validation '42'.encode('UTF-16') do
+          error '/', 'String is 6 characters long but must be at most 2.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_enum
+        schema :string, enum: ['foo']
+
+        assert_validation invalid_string do
+          error '/', 'Value not included in enum ["foo"].'
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_validate_self
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "encoding" must be a string or an array of strings.' do
+          schema :string, encoding: 123
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "encoding" must be a string or an array of strings.' do
+          schema :string, encoding: [123]
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "encoding" contains unknown encoding "UNKNOWN-FOO".' do
+          schema :string, encoding: 'UNKNOWN-FOO'
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "encoding" contains unknown encoding "UNKNOWN-FOO".' do
+          schema :string, encoding: %w[UTF-8 UNKNOWN-FOO]
+        end
+      end
+
       def test_empty_or_whitespace_string_blank_not_allowed
         schema :string, allow_blank: false
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: schemacop
 version: !ruby/object:Gem::Version
-  version: 3.0.39
+  version: 3.1.1
 platform: ruby
 authors:
 - Sitrox
 bindir: bin
 cert_chain: []
-date: 2026-03-26 00:00:00.000000000 Z
+date: 2026-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -164,7 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.2
+rubygems_version: 4.0.8
 specification_version: 4
 summary: Schemacop validates ruby structures consisting of nested hashes and arrays
   against simple schema definitions.