json_schemer-fuzz 1.0.0

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

@@ -0,0 +1,39 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class Required
+        class << self
+          def invalid_params(attributes)
+            required_properties = attributes["required"]
+            raise "No required keyword given: #{attributes}" unless required_properties
+
+            generated_params = []
+
+            required_properties.each do |property|
+              template = JSONSchemer::Fuzz.default_param(attributes)
+              template.delete(property)
+              generated_params << template
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes)
+            required_properties = attributes["required"]
+            raise "No required keyword given: #{attributes}" unless required_properties
+
+            generated_param = {}
+
+            required_properties.each do |property|
+              properties_key = attributes.key?("members") ? "members" : "properties"
+              attribute = attributes[properties_key][property]
+              generated_param[property] = JSONSchemer::Fuzz.default_param(attribute)
+            end
+
+            generated_param
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+      class UniqueItems
+        class << self
+          def invalid_params(attributes)
+            unique_items_flag = attributes["uniqueItems"]
+            raise "No uniqueItems keyword given: #{attributes}" if unique_items_flag.nil?
+            return unless unique_items_flag
+
+            generated_params = []
+            template = valid_param(attributes)
+            template << template.sample
+            generated_params << template
+
+            generated_params
+          end
+
+          def valid_param(attributes)
+            attributes = Marshal.load(Marshal.dump(attributes))
+            unique_items_flag = attributes.delete("uniqueItems")
+            raise "No uniqueItems keyword given: #{attributes}" if unique_items_flag.nil?
+            return unless unique_items_flag
+
+            JSONSchemer::Fuzz.generators("array").valid_param(attributes).uniq
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/keyword.rb

@@ -0,0 +1,29 @@
+module JSONSchemer
+  module Fuzz
+    class Keyword
+    end
+  end
+end
+
+require_relative "keyword/additional_properties"
+require_relative "keyword/all_of"
+require_relative "keyword/any_of"
+require_relative "keyword/dependencies"
+require_relative "keyword/enum"
+require_relative "keyword/format"
+require_relative "keyword/items"
+require_relative "keyword/max_items"
+require_relative "keyword/max_length"
+require_relative "keyword/max_properties"
+require_relative "keyword/maximum"
+require_relative "keyword/min_items"
+require_relative "keyword/min_length"
+require_relative "keyword/min_properties"
+require_relative "keyword/minimum"
+require_relative "keyword/multiple_of"
+require_relative "keyword/not"
+require_relative "keyword/one_of"
+require_relative "keyword/pattern"
+require_relative "keyword/properties"
+require_relative "keyword/required"
+require_relative "keyword/unique_items"

data/lib/json_schemer/fuzz/primitive_type/array.rb

@@ -0,0 +1,50 @@
+module JSONSchemer
+  module Fuzz
+    class PrimitiveType
+      class Array
+        class << self
+          def invalid_params(attributes)
+            generated_params = []
+
+            if type = attributes["type"]
+              JSONSchemer::Fuzz::PrimitiveType.invalid_params_by_type(attributes).each do |invalid_param|
+                generated_params.push(invalid_param)
+              end
+            end
+
+            attributes.each do |keyword, attribute|
+              if klass = keyword_to_class_map[keyword]
+                klass.invalid_params(attributes).each do |invalid_param|
+                  generated_params << invalid_param
+                end
+              end
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes = {})
+            valid_params = []
+
+            attributes.each do |keyword, attribute|
+              if klass = keyword_to_class_map[keyword]
+                valid_params << klass.valid_param(attributes)
+              end
+            end
+
+            valid_params.empty? ? ["sample", "array"] : valid_params.sample
+          end
+
+          def keyword_to_class_map
+            {
+              "minItems" => JSONSchemer::Fuzz::Keyword::MinItems,
+              "maxItems" => JSONSchemer::Fuzz::Keyword::MaxItems,
+              "uniqueItems" => JSONSchemer::Fuzz::Keyword::UniqueItems,
+              "items" => JSONSchemer::Fuzz::Keyword::Items,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/primitive_type/boolean.rb

@@ -0,0 +1,29 @@
+module JSONSchemer
+  module Fuzz
+    class PrimitiveType
+      class Boolean
+        class << self
+          def invalid_params(attributes)
+            generated_params = []
+
+            if type = attributes["type"]
+              valid_types = [type].flatten
+              generated_params = ["true", "false", "1", "0"] unless valid_types.include?("string")
+              JSONSchemer::Fuzz::PrimitiveType.invalid_params_by_type(attributes).each do |invalid_param|
+                generated_params.push(invalid_param)
+              end
+            else
+              generated_params = ["true", "false", "1", "0"]
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes = {})
+            [true, false].sample
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/primitive_type/integer.rb

@@ -0,0 +1,55 @@
+module JSONSchemer
+  module Fuzz
+    class PrimitiveType
+      class Integer
+        class << self
+          def invalid_params(attributes)
+            generated_params = []
+            if type = attributes["type"]
+              valid_types = [type].flatten
+              # TODO: Ideally this array would include a string number, as that is the intent here
+              ["&"].each { |val| generated_params << val } unless valid_types.include?("string")
+              # TODO: Ideally 0.1 would work here as invalid, as it is not an integer
+              #       But it doesn't, so instead we use an array
+              generated_params << [0.1] unless valid_types.include?("number")
+              JSONSchemer::Fuzz::PrimitiveType.invalid_params_by_type(attributes).each do |invalid_param|
+                generated_params << invalid_param
+              end
+            else
+              generated_params = ["#"]
+            end
+
+            attributes.each do |keyword, attribute|
+              if (klass = keyword_to_class_map[keyword])
+                klass.invalid_params(attributes).each do |invalid_param|
+                  generated_params << invalid_param
+                end
+              end
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes = {})
+            valid_params = []
+            attributes.each do |keyword, attribute|
+              if klass = keyword_to_class_map[keyword]
+                valid_params << klass.valid_param(attributes)
+              end
+            end
+
+            valid_params.empty? ? rand(100) : valid_params.sample
+          end
+
+          def keyword_to_class_map
+            {
+              "minimum" => JSONSchemer::Fuzz::Keyword::Minimum,
+              "maximum" => JSONSchemer::Fuzz::Keyword::Maximum,
+              "multipleOf" => JSONSchemer::Fuzz::Keyword::MultipleOf,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/primitive_type/null.rb

@@ -0,0 +1,30 @@
+module JSONSchemer
+  module Fuzz
+    class PrimitiveType
+      class Null
+        class << self
+          def invalid_params(attributes)
+            generated_params = []
+            if type = attributes["type"]
+              valid_types = [type].flatten
+              generated_params = ["nil", "0", "null", ""] unless valid_types.include?("string")
+              generated_params.push(false) unless valid_types.include?("boolean")
+
+              JSONSchemer::Fuzz::PrimitiveType.invalid_params_by_type(attributes).each do |invalid_param|
+                generated_params.push(invalid_param)
+              end
+            else
+              generated_params = ["nil", "0", "null", false, ""]
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes = {})
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/primitive_type/number.rb

@@ -0,0 +1,50 @@
+module JSONSchemer
+  module Fuzz
+    class PrimitiveType
+      class Number
+        class << self
+          def invalid_params(attributes)
+            generated_params = []
+            if type = attributes["type"]
+              valid_types = [type].flatten
+              generated_params = ["0.1", "10", "hoge"] unless valid_types.include?("string")
+              JSONSchemer::Fuzz::PrimitiveType.invalid_params_by_type(attributes).each do |invalid_param|
+                generated_params << invalid_param
+              end
+            end
+
+            attributes.each do |keyword, attribute|
+              if klass = keyword_to_class_map[keyword]
+                klass.invalid_params(attributes).each do |invalid_param|
+                  generated_params << invalid_param
+                end
+              end
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes = {})
+            valid_params = []
+
+            attributes.each do |keyword, attribute|
+              if klass = keyword_to_class_map[keyword]
+                valid_params << klass.valid_param(attributes).to_f
+              end
+            end
+
+            valid_params.empty? ? rand : valid_params.sample
+          end
+
+          def keyword_to_class_map
+            {
+              "minimum" => JSONSchemer::Fuzz::Keyword::Minimum,
+              "maximum" => JSONSchemer::Fuzz::Keyword::Maximum,
+              "multipleOf" => JSONSchemer::Fuzz::Keyword::MultipleOf,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/primitive_type/object.rb

@@ -0,0 +1,54 @@
+module JSONSchemer
+  module Fuzz
+    class PrimitiveType
+      class Object
+        class << self
+          def invalid_params(attributes)
+            generated_params = []
+
+            if type = attributes["type"]
+              valid_types = [type].flatten
+              JSONSchemer::Fuzz::PrimitiveType.invalid_params_by_type(attributes).each do |invalid_param|
+                generated_params.push(invalid_param)
+              end
+            end
+
+            attributes.each do |keyword, attribute|
+              if klass = keyword_to_class_map[keyword]
+                klass.invalid_params(attributes).each do |invalid_param|
+                  generated_params << invalid_param
+                end
+              end
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes = {})
+            generated_params = {}
+
+            attributes.each do |keyword, attribute|
+              if klass = keyword_to_class_map[keyword]
+                generated_params.merge!(klass.valid_param(attributes))
+              end
+            end
+
+            generated_params
+          end
+
+          def keyword_to_class_map
+            {
+              "members" => JSONSchemer::Fuzz::Keyword::Properties,
+              "properties" => JSONSchemer::Fuzz::Keyword::Properties,
+              "required" => JSONSchemer::Fuzz::Keyword::Required,
+              "minProperties" => JSONSchemer::Fuzz::Keyword::MinProperties,
+              "maxProperties" => JSONSchemer::Fuzz::Keyword::MaxProperties,
+              "additionalProperties" => JSONSchemer::Fuzz::Keyword::AdditionalProperties,
+              "dependencies" => JSONSchemer::Fuzz::Keyword::Dependencies,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/primitive_type/string.rb

@@ -0,0 +1,50 @@
+module JSONSchemer
+  module Fuzz
+    class PrimitiveType
+      class String
+        class << self
+          def invalid_params(attributes)
+            generated_params = []
+            if type = attributes["type"]
+              valid_types = [type].flatten
+              JSONSchemer::Fuzz::PrimitiveType.invalid_params_by_type(attributes).each do |invalid_param|
+                generated_params.push(invalid_param)
+              end
+            end
+
+            attributes.each do |keyword, attribute|
+              if klass = keyword_to_class_map[keyword]
+                klass.invalid_params(attributes).each do |invalid_param|
+                  generated_params << invalid_param
+                end
+              end
+            end
+
+            generated_params.empty? ? [1] : generated_params
+          end
+
+          def valid_param(attributes = {})
+            generated_params = []
+
+            attributes.each do |keyword, attribute|
+              if klass = keyword_to_class_map[keyword]
+                generated_params << klass.valid_param(attributes)
+              end
+            end
+
+            generated_params.empty? ? "hoge" : generated_params.sample
+          end
+
+          def keyword_to_class_map
+            {
+              "pattern" => JSONSchemer::Fuzz::Keyword::Pattern,
+              "minLength" => JSONSchemer::Fuzz::Keyword::MinLength,
+              "maxLength" => JSONSchemer::Fuzz::Keyword::MaxLength,
+              "format" => JSONSchemer::Fuzz::Keyword::Format,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/primitive_type.rb

@@ -0,0 +1,31 @@
+require_relative "primitive_type/array"
+require_relative "primitive_type/boolean"
+require_relative "primitive_type/integer"
+require_relative "primitive_type/null"
+require_relative "primitive_type/number"
+require_relative "primitive_type/object"
+require_relative "primitive_type/string"
+
+module JSONSchemer
+  module Fuzz
+    class PrimitiveType
+      class << self
+        def invalid_params_by_type(attributes)
+          type = attributes["type"]
+          raise "No type given: #{attributes}" unless type
+
+          valid_types = [type].flatten
+          valid_types.push("integer") if valid_types.include?("number")
+
+          invalid_params = []
+
+          GENERATOR_MAP.each do |key, klass|
+            invalid_params.push(klass.valid_param(attributes)) unless valid_types.include?(key)
+          end
+
+          invalid_params
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/fuzz/version.rb

@@ -0,0 +1,7 @@
+module JSONSchemer
+  module Fuzz
+    module Version
+      VERSION = "1.0.0"
+    end
+  end
+end

data/lib/json_schemer/fuzz.rb

@@ -0,0 +1,170 @@
+# External gems
+require "version_gem"
+require "json_schemer"
+require "file_exists" # must load before randexp
+require "randexp"
+
+# This gem
+require_relative "fuzz/version"
+require_relative "fuzz/keyword"
+require_relative "fuzz/primitive_type"
+
+module JSONSchemer
+  module Fuzz
+    GENERATOR_MAP = {
+      "array" => JSONSchemer::Fuzz::PrimitiveType::Array,
+      "boolean" => JSONSchemer::Fuzz::PrimitiveType::Boolean,
+      "integer" => JSONSchemer::Fuzz::PrimitiveType::Integer,
+      "null" => JSONSchemer::Fuzz::PrimitiveType::Null,
+      "number" => JSONSchemer::Fuzz::PrimitiveType::Number,
+      "object" => JSONSchemer::Fuzz::PrimitiveType::Object,
+      "string" => JSONSchemer::Fuzz::PrimitiveType::String,
+    }.freeze
+
+    extend self
+
+    def generators(type)
+      raise "no generator for #{type}" unless GENERATOR_MAP.key?(type)
+
+      GENERATOR_MAP[type]
+    end
+
+    # Generate invalid data
+    def generate(schema)
+      schema = JSON.parse(open(schema).read) if schema.instance_of?(String)
+      generated_params = []
+
+      if (type = schema["type"])
+        if type.instance_of?(Array) # union type
+          all_types.each do |target_type|
+            if type.include?(target_type)
+              generators(target_type).invalid_params(schema).each do |invalid_param|
+                generated_params.push(invalid_param)
+              end
+            else
+              generated_params.push(generators(target_type).invalid_params("type" => target_type))
+            end
+          end
+        elsif type == "any"
+          # do nothing
+        else
+          generators(type).invalid_params(schema).each do |invalid_param|
+            generated_params.push(invalid_param)
+          end
+        end
+      elsif schema.key?("members") || schema.key?("properties")
+        generators("object").invalid_params(schema).each do |invalid_param|
+          generated_params.push(invalid_param)
+        end
+      elsif schema.empty?
+        # do nothing
+      elsif schema.key?("minimum") || schema.key?("maximum")
+        generators("number").invalid_params(schema).each do |invalid_param|
+          generated_params.push(invalid_param)
+        end
+      elsif schema.key?("minItems") || schema.key?("maxItems")
+        generators("array").invalid_params(schema).each do |invalid_param|
+          generated_params << invalid_param
+        end
+      elsif schema.key?("minProperties") || schema.key?("maxProperties")
+        generators("object").invalid_params(schema).each do |invalid_param|
+          generated_params << invalid_param
+        end
+      elsif schema.key?("uniqueItems")
+        generators("array").invalid_params(schema).each do |invalid_param|
+          generated_params << invalid_param
+        end
+      elsif schema.key?("pattern")
+        generators("string").invalid_params(schema).each do |invalid_param|
+          generated_params << invalid_param
+        end
+      elsif schema.key?("minLength") || schema.key?("maxLength")
+        generators("string").invalid_params(schema).each do |invalid_param|
+          generated_params << invalid_param
+        end
+      elsif schema.key?("enum")
+        JSONSchemer::Fuzz::Keyword::Enum.invalid_params(schema).each do |invalid_param|
+          generated_params << invalid_param
+        end
+      elsif schema.key?("multipleOf")
+        generators("number").invalid_params(schema).each do |invalid_param|
+          generated_params << invalid_param
+        end
+      elsif schema.key?("items")
+        generators("array").invalid_params(schema).each do |invalid_param|
+          generated_params << invalid_param
+        end
+      elsif schema.key?("$ref")
+        raise "not impremented yet"
+      elsif schema.key?("allOf") || schema.key?("anyOf") || schema.key?("oneOf")
+        generators("object").invalid_params(schema).each do |invalid_param|
+          generated_params << invalid_param
+        end
+      elsif schema.key?("not")
+        JSONSchemer::Fuzz::Keyword::Not.invalid_params(schema).each do |invalid_param|
+          generated_params << invalid_param
+        end
+      else
+        raise "Not implemented generator for schema:#{schema}"
+      end
+
+      generated_params
+    end
+
+    # Generate valid data
+    def default_param(schema)
+      schema = JSON.parse(open(schema).read) if schema.instance_of?(String)
+
+      if (type = schema["type"])
+        type = type.sample if type.instance_of?(Array)
+        type = all_types.sample if type == "any"
+        generators(type).valid_param(schema)
+      elsif schema.key?("properties")
+        generators("object").valid_param(schema)
+      elsif schema.empty?
+        _, generator = JSONSchemer::Fuzz::GENERATOR_MAP.to_a.sample
+        generator.valid_param
+      elsif schema.key?("minimum") || schema.key?("maximum")
+        generators("number").valid_param(schema)
+      elsif schema.key?("minItems") || schema.key?("maxItems")
+        generators("array").valid_param(schema)
+      elsif schema.key?("minProperties") || schema.key?("maxProperties")
+        generators("object").valid_param(schema)
+      elsif schema.key?("uniqueItems")
+        generators("array").valid_param(schema)
+      elsif schema.key?("pattern")
+        generators("string").valid_param(schema)
+      elsif schema.key?("minLength") || schema.key?("maxLength")
+        generators("string").valid_param(schema)
+      elsif schema.key?("enum")
+        JSONSchemer::Fuzz::Keyword::Enum.valid_param(schema)
+      elsif schema.key?("multipleOf")
+        generators("number").valid_param(schema)
+      elsif schema.key?("items")
+        generators("array").valid_param(schema)
+      elsif schema.key?("$ref")
+        raise "not impremented yet"
+      elsif schema.key?("allOf")
+        JSONSchemer::Fuzz::Keyword::AllOf.valid_param(schema)
+      elsif schema.key?("anyOf")
+        JSONSchemer::Fuzz::Keyword::AnyOf.valid_param(schema)
+      elsif schema.key?("oneOf")
+        JSONSchemer::Fuzz::Keyword::OneOf.valid_param(schema)
+      elsif schema.key?("not")
+        JSONSchemer::Fuzz::Keyword::Not.valid_param(schema)
+      else
+        raise "Not implemented generator for schema:#{schema}"
+      end
+    end
+
+    private
+
+    def all_types
+      %w[array boolean integer null number object string]
+    end
+  end
+end
+
+JSONSchemer::Fuzz::Version.class_eval do
+  extend VersionGem::Basic
+end

data/lib/json_schemer-fuzz.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# This file should be required by any tools (e.g. bundler) loading this library
+# Bundler should automatically load this file, based on RubyGems' directory and naming conventions.
+# For technical reasons, this cannot be require_relative.
+#   See: https://github.com/fxn/zeitwerk#for_gem_extension
+require "json_schemer/fuzz"