json_schemer-fuzz 1.0.0

data/lib/json_schemer/fuzz/keyword/format.rb

@@ -0,0 +1,119 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class Format
+        class << self
+          # @return Array
+          def invalid_params(attributes)
+            format = attributes["format"]
+            raise "No format keyword given: #{attributes}" unless format
+
+            if invalid_params = format_to_invalid_params(format)
+              invalid_params
+            else
+              raise "invalid format type: #{attributes}"
+            end
+          end
+
+          def valid_param(attributes)
+            format = attributes["format"]
+            raise "No format keyword given: #{attributes}" unless format
+
+            if valid_params = format_to_valid_params(format)
+              valid_params.sample
+            else
+              raise "invalid format type: #{attributes}"
+            end
+          end
+
+          private
+
+          def format_to_invalid_params(format)
+            {
+              "ipv4" => [
+                "1",
+                "1.1",
+                "1.1.1",
+                "1.1.1.1.1.1.1.1.1.1.1.1.1",
+                "1.1.1.300",
+                "1.1.1.1b",
+                "b1.1.1.1",
+                "donut",
+              ],
+              "ipv6" => [
+                "1111:2222:8888:99999:aaaa:cccc:eeee:ffff",
+                "1111:2222:8888:9999:aaaa:cccc:eeee:gggg",
+                "1111:2222::9999::cccc:eeee:ffff",
+                "1111:2222:8888:9999:aaaa:cccc:eeee:ffff:bbbb",
+              ],
+              # https://ijmacd.github.io/rfc3339-iso8601/
+              "time" => [
+                "12:00",
+                "12:00:60",
+                "12:60:00",
+                "24:00:00",
+                "0:00:00",
+                "-12:00:00",
+                "12:00:00b",
+                "12:00:00",
+              ],
+              # https://ijmacd.github.io/rfc3339-iso8601/
+              "date" => [
+                "2010-01-32",
+                "n2010-01-01",
+                "2010-1-01",
+                "2010-01-1",
+                "2010-01-01n",
+              ],
+              # https://ijmacd.github.io/rfc3339-iso8601/
+              "date-time" => [
+                "2010-01-32T12:00:00Z",
+                "2010-13-01T12:00:00Z",
+                "2010-01-01T24:00:00Z",
+                "2010-01-01T12:60:00Z",
+                "2010-01-01T12:00:60Z",
+                "2010-01-0112:00:00Z",
+                "2010-01-01T12:00:00+0000",
+              ],
+              "uri" => [
+                "::hoge",
+              ],
+              "email" => [
+                "@example.com",
+                "hoge",
+                "http://example.com",
+              ],
+            }[format]
+          end
+
+          def format_to_valid_params(format)
+            {
+              "ipv4" => ["1.1.1.1"],
+              "ipv6" => [
+                "1111:2222:8888:9999:aaaa:cccc:eeee:ffff",
+                "1111:0:8888:0:0:0:eeee:ffff",
+                "1111:2222:8888::eeee:ffff",
+              ],
+              # https://ijmacd.github.io/rfc3339-iso8601/
+              "time" => ["12:00:00Z"],
+              # https://ijmacd.github.io/rfc3339-iso8601/
+              "date" => ["1992-06-27"],
+              # https://ijmacd.github.io/rfc3339-iso8601/
+              "date-time" => [
+                "2010-01-01T12:00:00Z",
+                "2010-01-01T12:00:00.1Z",
+                # TODO: Uncomment once fixed in json_schemer: https://github.com/davishmcclurg/json_schemer/issues/151
+                #       Valid ISO-8601, but not valid RFC-3339
+                # "2010-01-01T12:00:00,1Z",
+                "2010-01-01T12:00:00z", # RFC-3339 is case-insensitive!
+                "2010-01-01T12:00:00+00:00",
+              ],
+              "uri" => ["http://example.com"],
+              "email" => ["hoge@example.com"],
+            }[format]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/items.rb

@@ -0,0 +1,67 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class Items
+        class << self
+          # @return Array
+          def invalid_params(attributes)
+            attributes = Marshal.load(Marshal.dump(attributes))
+            items = attributes.delete("items")
+            raise "No items keyword given: #{attributes}" unless items
+
+            generated_params = []
+
+            if items.instance_of?(Hash)
+              invalid_param = []
+              JSONSchemer::Fuzz.generate(items).each do |invalid_item|
+                invalid_param << invalid_item
+              end
+              generated_params << invalid_param
+            else
+              invalid_param = []
+              items.each do |item|
+                JSONSchemer::Fuzz.generate(item).each do |invalid_item|
+                  invalid_param << invalid_item
+                end
+              end
+              generated_params << invalid_param
+            end
+
+            if attributes.key?("additionalItems")
+              additional_items = attributes.delete("additionalItems")
+              template = valid_param(attributes.merge("items" => items))
+
+              if additional_items
+                template << JSONSchemer::Fuzz.generate(additional_items).sample
+                generated_params << template
+              else
+                template << template.sample
+                generated_params << template
+              end
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes)
+            attributes = Marshal.load(Marshal.dump(attributes))
+            items = attributes.delete("items")
+            raise "No items keyword given: #{attributes}" unless items
+
+            generated_param = []
+
+            if items.instance_of?(Hash)
+              generated_param << JSONSchemer::Fuzz.default_param(items)
+            else
+              items.each do |item|
+                generated_param << JSONSchemer::Fuzz.default_param(item)
+              end
+            end
+
+            generated_param
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/max_items.rb

@@ -0,0 +1,43 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class MaxItems
+        class << self
+          # @return Array
+          def invalid_params(attributes)
+            attributes = Marshal.load(Marshal.dump(attributes))
+            max_items = attributes.delete("maxItems")
+            raise "No maxItems keyword given: #{attributes}" unless max_items
+
+            generated_params = []
+            invalid_param = []
+
+            (max_items + 1).times do
+              item = JSONSchemer::Fuzz.default_param(attributes)
+              item = "null" if item.nil?
+              invalid_param << item
+            end
+
+            generated_params << invalid_param
+
+            generated_params
+          end
+
+          def valid_param(attributes)
+            attributes = Marshal.load(Marshal.dump(attributes))
+            max_items = attributes.delete("maxItems")
+            raise "No maxItems keyword given: #{attributes}" unless max_items
+
+            generated_param = []
+
+            max_items.times do
+              generated_param << JSONSchemer::Fuzz.default_param(attributes)
+            end
+
+            generated_param
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/max_length.rb

@@ -0,0 +1,28 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class MaxLength
+        class << self
+          # @return Array
+          def invalid_params(attributes)
+            max_length = attributes["maxLength"]
+            raise "No maxLength keyword given: #{attributes}" unless max_length
+
+            generated_params = []
+
+            generated_params << /\w{1}/.gen * (max_length + 1)
+
+            generated_params
+          end
+
+          def valid_param(attributes)
+            max_length = attributes["maxLength"]
+            raise "No maxLength keyword given: #{attributes}" unless max_length
+
+            /\w{1}/.gen * max_length
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/max_properties.rb

@@ -0,0 +1,43 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class MaxProperties
+        class << self
+          # @return Array
+          def invalid_params(attributes)
+            max_properties = attributes["maxProperties"]
+            raise "No maxProperties keyword given: #{attributes}" unless max_properties
+
+            generated_params = []
+            invalid_param = {}
+
+            template = valid_param(attributes)
+
+            while template.size <= max_properties
+              key = /\w+/.gen
+              template[key] = template[template.keys.sample]
+            end
+
+            [template]
+          end
+
+          def valid_param(attributes)
+            attributes = Marshal.load(Marshal.dump(attributes))
+            max_properties = attributes.delete("maxProperties")
+            raise "No maxProperties keyword given: #{attributes}" unless max_properties
+
+            template = JSONSchemer::Fuzz.default_param(attributes)
+
+            while template.size > max_properties
+              requred_keys = attributes["required"] || []
+              key = (template.keys - requred_keys).sample
+              template.delete(template.keys.sample)
+            end
+
+            template
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/maximum.rb

@@ -0,0 +1,44 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class Maximum
+        class << self
+          def invalid_params(attributes)
+            maximum_value = attributes["maximum"]
+            raise "No maximum keyword given: #{attributes}" unless maximum_value
+
+            generated_params = []
+            unit_value = (attributes.key?("type") && attributes["type"] == "integer") ? 1 : 0.1
+
+            if attributes["exclusiveMaximum"]
+              generated_params.push(maximum_value)
+            else
+              generated_params.push(maximum_value + unit_value)
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes)
+            maximum_value = attributes["maximum"]
+            raise "No maximum keyword given: #{attributes}" unless maximum_value
+
+            unit_value = (attributes.key?("type") && attributes["type"] == "integer") ? 1 : 0.1
+            maximum_value -= unit_value if attributes["exclusiveMaximum"]
+
+            if minimum_value = attributes["minimum"]
+              minimum_value += unit_value if attributes["exclusiveMinimum"]
+              if attributes["exclusiveMaximum"]
+                Random.rand(minimum_value...maximum_value)
+              else
+                Random.rand(minimum_value..maximum_value)
+              end
+            else
+              maximum_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/min_items.rb

@@ -0,0 +1,42 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class MinItems
+        class << self
+          def invalid_params(attributes)
+            attributes = Marshal.load(Marshal.dump(attributes))
+            min_items = attributes.delete("minItems")
+            raise "No minItems keyword given: #{attributes}" unless min_items
+
+            generated_params = []
+            invalid_param = []
+
+            (min_items - 1).times do
+              invalid_param << JSONSchemer::Fuzz.default_param(attributes)
+            end
+
+            generated_params << invalid_param
+
+            generated_params
+          end
+
+          def valid_param(attributes)
+            attributes = Marshal.load(Marshal.dump(attributes))
+            min_items = attributes.delete("minItems")
+            raise "No minItems keyword given: #{attributes}" unless min_items
+
+            generated_param = []
+
+            min_items.times do
+              item = JSONSchemer::Fuzz.default_param(attributes)
+              item = "null" if item.nil?
+              generated_param << "null"
+            end
+
+            generated_param
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/min_length.rb

@@ -0,0 +1,27 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class MinLength
+        class << self
+          def invalid_params(attributes)
+            min_length = attributes["minLength"]
+            raise "No minLength keyword given: #{attributes}" unless min_length
+
+            generated_params = []
+
+            generated_params << /\w{1}/.gen * (min_length - 1)
+
+            generated_params
+          end
+
+          def valid_param(attributes)
+            min_length = attributes["minLength"]
+            raise "No minLength keyword given: #{attributes}" unless min_length
+
+            /\w{1}/.gen * min_length
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/min_properties.rb

@@ -0,0 +1,37 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class MinProperties
+        class << self
+          def invalid_params(attributes)
+            min_properties = attributes["minProperties"]
+            raise "No minProperties keyword given: #{attributes}" unless min_properties
+
+            generated_params = []
+            invalid_param = {}
+
+            template = valid_param(attributes)
+            template.delete(template.keys.sample)
+
+            [template]
+          end
+
+          def valid_param(attributes)
+            attributes = Marshal.load(Marshal.dump(attributes))
+            min_properties = attributes.delete("minProperties")
+            raise "No minProperties keyword given: #{attributes}" unless min_properties
+
+            template = JSONSchemer::Fuzz.default_param(attributes)
+
+            while template.size < min_properties
+              key = /\w+/.gen
+              template[key] = template[template.keys.sample]
+            end
+
+            template
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/minimum.rb

@@ -0,0 +1,43 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class Minimum
+        class << self
+          def invalid_params(attributes)
+            minimum_value = attributes["minimum"]
+            raise "No minimum keyword given: #{attributes}" unless minimum_value
+
+            generated_params = []
+            unit_value = (attributes.key?("type") && attributes["type"] == "integer") ? 1 : 0.1
+
+            if attributes["exclusiveMinimum"]
+              generated_params.push(minimum_value)
+            else
+              generated_params.push(minimum_value - unit_value)
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes)
+            minimum_value = attributes["minimum"]
+            raise "No minimum keyword given: #{attributes}" unless minimum_value
+
+            unit_value = (attributes.key?("type") && attributes["type"] == "integer") ? 1 : 0.1
+            minimum_value += unit_value if attributes["exclusiveMinimum"]
+
+            if maximum_value = attributes["maximum"]
+              if attributes["exclusiveMaximum"]
+                Random.rand(minimum_value...maximum_value)
+              else
+                Random.rand(minimum_value..maximum_value)
+              end
+            else
+              minimum_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/multiple_of.rb

@@ -0,0 +1,27 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class MultipleOf
+        class << self
+          def invalid_params(attributes)
+            multiple_of = attributes["multipleOf"]
+            raise "No multipleOf keyword given: #{attributes}" unless multiple_of
+
+            [multiple_of * 0.9]
+          end
+
+          def valid_param(attributes)
+            multiple_of = attributes["multipleOf"]
+            raise "No multipleOf keyword given: #{attributes}" unless multiple_of
+
+            string_num = multiple_of.to_s
+            demicals = (string_num.split(".").length == 2) ? string_num.split(".")[-1].length : 0
+
+            multiple_num = ("%.#{demicals}f" % (multiple_of * Random.rand(1..10)))
+            multiple_of.instance_of?(Float) ? multiple_num.to_f : multiple_num.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/not.rb

@@ -0,0 +1,26 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class Not
+        class << self
+          def invalid_params(attributes)
+            not_attribute = attributes["not"]
+            raise "No not keyword given: #{attributes}" unless not_attribute
+
+            [JSONSchemer::Fuzz.default_param(not_attribute)]
+          end
+
+          def valid_param(attributes)
+            attributes = Marshal.load(Marshal.dump(attributes))
+            not_attribute = attributes.delete("not")
+            raise "No not keyword given: #{attributes}" unless not_attribute
+
+            generated_params = JSONSchemer::Fuzz.generate(not_attribute)
+
+            generated_params.sample
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/one_of.rb

@@ -0,0 +1,74 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class OneOf
+        class << self
+          def invalid_params(attributes)
+            one_of = attributes["oneOf"]
+            raise "No oneOf keyword given: #{attributes}" unless one_of
+            raise "oneOf keyword given, but had no schemas: #{attributes["oneOf"]}" unless one_of.any?
+
+            generated_params = []
+
+            # Either all params need to be invalid, or all need to be valid.
+            # For simplicity, we'll start with all invalid,
+            #   but this could be extended to sometimes return all valid.
+            one_of.each do |schema|
+              temp_params = JSONSchemer::Fuzz.generate(schema).reject do |param|
+                ::JSONSchemer.schema(attributes).validate(param)
+              end
+              generated_params.concat(temp_params)
+            end
+
+            raise "failed to generate invalid_params for schema: #{attributes}" if generated_params.empty?
+            [generated_params.uniq.sample]
+          end
+
+          def valid_param(attributes)
+            one_of = attributes["oneOf"]
+            raise "No oneOf keyword given: #{attributes}" unless one_of
+            raise "oneOf keyword given, but had no schemas: #{attributes["oneOf"]}" unless one_of.any?
+
+            generated_params = []
+
+            # Only one of the oneOf can be valid, the others must not be, as it is an XOR
+            # If one of the oneOf's is required,
+            #   then then match for that schema cannot also match the other schemas.
+            required_schema_index = one_of.index { |oof| oof["required"] }
+            required_schema = one_of.delete_at(required_schema_index)
+            if required_schema
+              valid_required_param = JSONSchemer::Fuzz.default_param(required_schema).detect do |param|
+                ::JSONSchemer.schema(attributes).validate(param)
+              end
+              if valid_required_param
+                generated_params << valid_required_param
+              else
+                one_of.each do |schema|
+                  temp_param = JSONSchemer::Fuzz.generate(schema).detect do |param|
+                    ::JSONSchemer.schema(attributes).validate(param)
+                  end
+                  if temp_param
+                    generated_params << temp_param
+                  else
+                    # Allow to drop through to attempt to find another part of the oneOf to satisfy
+                  end
+                end
+              end
+            end
+
+            return generated_params.uniq.sample if generated_params.any?
+
+            one_of.each do |schema|
+              generated_params.concat(JSONSchemer::Fuzz.generate(schema).select do |param|
+                ::JSONSchemer.schema(attributes).validate(param)
+              end)
+            end
+
+            raise "failed to generate invalid_params for schema: #{attributes}" if generated_params.empty?
+            generated_params.uniq.sample
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/pattern.rb

@@ -0,0 +1,17 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class Pattern
+        class << self
+          def invalid_params(attributes)
+            raise "not implemented"
+          end
+
+          def valid_param(attributes)
+            raise "not implemented"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword/properties.rb

@@ -0,0 +1,38 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class Properties
+        class << self
+          def invalid_params(attributes)
+            properties = attributes["members"] || attributes["properties"]
+            raise "No properties or members keyword given: #{attributes}" unless properties
+
+            generated_params = []
+
+            properties.each do |key, attribute|
+              JSONSchemer::Fuzz.generate(attribute).each do |invalid_param|
+                template = JSONSchemer::Fuzz.default_param(attributes)
+                generated_params << template.merge(key => invalid_param)
+              end
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes)
+            properties = attributes["members"] || attributes["properties"]
+            raise "No properties or members keyword given: #{attributes}" unless properties
+
+            generated_param = {}
+
+            properties.each do |key, attribute|
+              generated_param[key] = JSONSchemer::Fuzz.default_param(attribute)
+            end
+
+            generated_param
+          end
+        end
+      end
+    end
+  end
+end