json-fuzz-generator 0.0.1

data/lib/json/fuzz/generator/primitive_type.rb

@@ -0,0 +1,40 @@
+module JSON
+  module Fuzz
+    module Generator
+      class PrimitiveType
+        Dir[File.join(File.dirname(__FILE__), "primitive_type/*.rb")].each {|file| require file }
+
+        class << self
+          def type_to_class_map
+            {
+              "array"   => JSON::Fuzz::Generator::PrimitiveType::Array,
+              "boolean" => JSON::Fuzz::Generator::PrimitiveType::Boolean,
+              "integer" => JSON::Fuzz::Generator::PrimitiveType::Integer,
+              "null"    => JSON::Fuzz::Generator::PrimitiveType::Null,
+              "number"  => JSON::Fuzz::Generator::PrimitiveType::Number,
+              "object"  => JSON::Fuzz::Generator::PrimitiveType::Object,
+              "string"  => JSON::Fuzz::Generator::PrimitiveType::String,
+            }
+          end
+
+          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 = []
+
+            type_to_class_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
+end
+

data/lib/json/fuzz/generator/primitive_type/array.rb

@@ -0,0 +1,53 @@
+module JSON 
+  module Fuzz
+    module Generator
+      class PrimitiveType
+        class Array
+          class << self
+            def invalid_params(attributes)
+              generated_params = []
+
+              if type = attributes["type"]
+                JSON::Fuzz::Generator::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"    => JSON::Fuzz::Generator::Keyword::MinItems,
+                "maxItems"    => JSON::Fuzz::Generator::Keyword::MaxItems,
+                "uniqueItems" => JSON::Fuzz::Generator::Keyword::UniqueItems,
+                "items"       => JSON::Fuzz::Generator::Keyword::Items,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/json/fuzz/generator/primitive_type/boolean.rb

@@ -0,0 +1,32 @@
+module JSON
+  module Fuzz
+    module Generator
+      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")
+                JSON::Fuzz::Generator::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
+end
+

data/lib/json/fuzz/generator/primitive_type/integer.rb

@@ -0,0 +1,56 @@
+module JSON
+  module Fuzz
+    module Generator
+      class PrimitiveType
+        class Integer
+          class << self
+            def invalid_params(attributes)
+              generated_params = []
+              if type = attributes["type"]
+                valid_types = [type].flatten
+                ["a", "1"].each {|val| generated_params << val} unless valid_types.include?("string")
+                generated_params << 0.1 unless valid_types.include?("number")
+                JSON::Fuzz::Generator::PrimitiveType.invalid_params_by_type(attributes).each do |invalid_param|
+                  generated_params << invalid_param
+                end
+              else
+                #generated_params = ["a", "1"]
+              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"    => JSON::Fuzz::Generator::Keyword::Minimum,
+                "maximum"    => JSON::Fuzz::Generator::Keyword::Maximum,
+                "multipleOf" => JSON::Fuzz::Generator::Keyword::MultipleOf,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/json/fuzz/generator/primitive_type/null.rb

@@ -0,0 +1,33 @@
+module JSON
+  module Fuzz
+    module Generator
+      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")
+
+                JSON::Fuzz::Generator::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
+end
+

data/lib/json/fuzz/generator/primitive_type/number.rb

@@ -0,0 +1,52 @@
+module JSON
+  module Fuzz
+    module Generator
+      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")
+                JSON::Fuzz::Generator::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"    => JSON::Fuzz::Generator::Keyword::Minimum,
+                "maximum"    => JSON::Fuzz::Generator::Keyword::Maximum,
+                "multipleOf" => JSON::Fuzz::Generator::Keyword::MultipleOf,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/fuzz/generator/primitive_type/object.rb

@@ -0,0 +1,57 @@
+module JSON
+  module Fuzz
+    module Generator
+      class PrimitiveType
+        class Object
+          class << self
+            def invalid_params(attributes)
+              generated_params = []
+
+              if type = attributes["type"]
+                valid_types = [type].flatten
+                JSON::Fuzz::Generator::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"              => JSON::Fuzz::Generator::Keyword::Properties,
+                "properties"           => JSON::Fuzz::Generator::Keyword::Properties,
+                "required"             => JSON::Fuzz::Generator::Keyword::Required,
+                "minProperties"        => JSON::Fuzz::Generator::Keyword::MinProperties,
+                "maxProperties"        => JSON::Fuzz::Generator::Keyword::MaxProperties,
+                "additionalProperties" => JSON::Fuzz::Generator::Keyword::AdditionalProperties,
+                "dependencies"         => JSON::Fuzz::Generator::Keyword::Dependencies,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/json/fuzz/generator/primitive_type/string.rb

@@ -0,0 +1,53 @@
+module JSON
+  module Fuzz
+    module Generator
+      class PrimitiveType
+        class String
+          class << self
+            def invalid_params(attributes)
+              generated_params = []
+              if type = attributes["type"]
+                valid_types = [type].flatten
+                JSON::Fuzz::Generator::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"   => JSON::Fuzz::Generator::Keyword::Pattern,
+                "minLength" => JSON::Fuzz::Generator::Keyword::MinLength,
+                "maxLength" => JSON::Fuzz::Generator::Keyword::MaxLength,
+                "format"    => JSON::Fuzz::Generator::Keyword::Format,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/json/fuzz/generator/version.rb

@@ -0,0 +1,7 @@
+module JSON
+  module Fuzz
+    module Generator
+      VERSION = "0.0.1"
+    end
+  end
+end

data/spec/json-fuzz-generator_spec.rb

@@ -0,0 +1,559 @@
+require "spec_helper"
+
+describe JSON::Fuzz do
+  shared_examples_for JSON::Fuzz::Generator do
+    context "#default_param" do
+      it "can generate valid parameter" do
+        valid_parameter = JSON::Fuzz::Generator.default_param(schema)
+        expect(valid_parameter).to be_matching_schema(schema)
+        #expect(JSON::Validator.validate(schema, valid_parameter)).to eq(true)
+      end
+    end
+
+    context "#generate" do
+      it "can generate invalid parameter" do
+        invalid_parameters = JSON::Fuzz::Generator.generate(schema)
+        invalid_parameters.each do |invalid_param|
+          expect(invalid_param).to be_not_matching_schema(schema)
+          #expect(JSON::Validator.validate(schema, invalid_param)).to eq(false)
+        end
+      end
+    end
+  end
+
+  context "types" do
+    %w(integer number string object array null any).each do |type|
+      context "when #{type}" do
+        it_behaves_like JSON::Fuzz::Generator do
+          let(:schema) {{
+            "$schema" => "http://json-schema.org/draft-04/schema#",
+            "type"    => type
+          }}
+        end
+      end
+    end
+
+    context "when union type" do
+      context "given integer and string" do
+        it_behaves_like JSON::Fuzz::Generator do
+          let(:schema) {{
+            "$schema" => "http://json-schema.org/draft-04/schema#", 
+            "type"    => ["integer", "string"],
+          }}
+        end
+      end
+
+      context "given string and null" do
+        it_behaves_like JSON::Fuzz::Generator do
+          let(:schema) {{
+            "$schema" => "http://json-schema.org/draft-04/schema#", 
+            "type"    => ["string", "null"],
+          }}
+        end
+      end
+
+      context "given integer and object" do
+        it_behaves_like JSON::Fuzz::Generator do
+          let(:schema) {{
+            "$schema" => "http://json-schema.org/draft-04/schema#", 
+            "type"    => ["integer", "object"],
+          }}
+        end
+      end
+    end
+  end
+
+  context "required" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#", 
+        "required"   => ["a"],
+        "properties" => {
+          "a" => {},
+        },
+      }}
+    end
+  end
+
+  context "minimum" do
+    context "without exclusiveMinimum" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#", 
+          "properties" => {
+            "a" => {"minimum" => 100},
+          },
+        }}
+      end
+    end
+
+    context "with exclusiveMinimum" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#", 
+          "properties" => {
+            "a" => {
+              "minimum"          => 100,
+              "exclusiveMinimum" => true,
+            },
+          },
+        }}
+      end
+    end
+  end
+
+  context "maximum" do
+    context "without exclusiveMaximum" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#", 
+          "properties" => {
+            "a" => {"maximum" => 3},
+          },
+        }}
+      end
+    end
+
+    context "with exclusiveMaximum" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#", 
+          "properties" => {
+            "a" => {
+              "maximum"          => 3,
+              "exclusiveMaximum" => true,
+            },
+          },
+        }}
+      end
+    end
+  end
+
+  context "minItems" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#", 
+        "properties" => {
+          "a" => {"minItems" => 5},
+        },
+      }}
+    end
+  end
+
+  context "maxItems" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#", 
+        "properties" => {
+          "a" => {"maxItems" => 3},
+        },
+      }}
+    end
+  end
+
+  context "minProperties" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"       => "http://json-schema.org/draft-04/schema#", 
+        "minProperties" => 2,
+        "properties"    => {},
+      }}
+    end
+  end
+
+  context "maxProperties" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"       => "http://json-schema.org/draft-04/schema#", 
+        "maxProperties" => 2,
+        "properties"    => {},
+      }}
+    end
+  end
+
+  xcontext "strict option" do
+    shared_examples_for JSON::Fuzz::Generator do
+      let(:generator) { JSON::Fuzz::Generator.new }
+
+      context "#default_param" do
+        it "can generate valid parameter" do
+          valid_parameter = generator.default_param(schema, :strict => true)
+          expect(JSON::Validator.validate(schema, valid_parameter, :strict => true)).to eq(true)
+        end
+      end
+
+      context "#generate" do
+        it "can generate invalid parameter" do
+          invalid_parameters = generator.generate(schema, :strict => true)
+          invalid_parameters.each do |invalid_param|
+            expect(JSON::Validator.validate(schema, invalid_param, :strict => true)).to eq(false)
+          end
+        end
+      end
+    end
+
+    context "without anly props" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#",
+          "properties" => {
+            "a" => {"type" => "string"},
+            "b" => {"type" => "string"},
+          },
+        }}
+      end
+    end
+
+    context "with additionalProperties" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"              => "http://json-schema.org/draft-04/schema#",
+          "additionalProperties" => {"type" => "integer"},
+          "properties"           => {
+            "a" => {"type" => "string"},
+            "b" => {"type" => "string"}
+          },
+        }}
+      end
+    end
+
+    xcontext "with patternProperties" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"           => "http://json-schema.org/draft-04/schema#",
+          "patternProperties" => {"\\d+ taco" => {"type" => "integer"}},
+          "properties"        => {
+            "a" => {"type" => "string"},
+            "b" => {"type" => "string"},
+          },
+        }}
+      end
+    end
+  end
+
+  context "uniqueItems" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#",
+        "properties" => {
+          "a" => {"uniqueItems" => true},
+        },
+      }}
+    end
+  end
+
+  xcontext "pattern" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#",
+        "properties" => {
+          "a" => {"pattern" => "\\d+ takoyaki"},
+        },
+      }}
+    end
+  end
+
+  context "minLength" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#",
+        "properties" => {
+          "a" => {"minLength" => 1},
+        },
+      }}
+    end
+  end
+
+  context "maxLength" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#",
+        "properties" => {
+          "a" => {"maxLength" => 1},
+        },
+      }}
+    end
+  end
+
+  context "enum" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#",
+        "properties" => {
+          "a" => {"enum" => ["hoge", 22, [0, 3], {"foo" => "bar"}]},
+        },
+      }}
+    end
+  end
+
+  context "multipleOf" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#",
+        "properties" => {
+          "a" => {"multipleOf" => 1.3},
+        },
+      }}
+    end
+  end
+
+  xcontext "patternProperties" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"           => "http://json-schema.org/draft-04/schema#",
+        "patternProperties" => {
+          "\\d+ takoyaki" => {"type" => "integer"},
+        },
+      }}
+    end
+  end
+
+  context "additionalProperties" do
+    context "given no properties" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#",
+          "properties" => {
+            "a" => {"type" => "integer"},
+          },
+          "additionalProperties" => false,
+        }}
+      end
+    end
+
+    context "given property of type" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#",
+          "properties" => {
+            "a" => {"type" => "integer"},
+          },
+          "additionalProperties" => {"type" => "string"},
+        }}
+      end
+    end
+
+    xcontext "with patternProperties" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"           => "http://json-schema.org/draft-04/schema#",
+          "patternProperties" => {
+            "\\d+ takoyaki" => {"type" => "integer"},
+          },
+          "additionalProperties" => false,
+        }}
+      end
+    end
+  end
+
+  context "items" do
+    context "given single property" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema" => "http://json-schema.org/draft-04/schema#",
+          "items"   => {"type" => "integer"},
+        }}
+      end
+    end
+
+    context "given multiple properties" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema" => "http://json-schema.org/draft-04/schema#",
+          "items"   => [
+            {"type" => "integer"},
+            {"type" => "string"},
+          ],
+        }}
+      end
+    end
+
+    context "with additionalItems" do
+      context "given false" do
+        it_behaves_like JSON::Fuzz::Generator do
+          let(:schema) {{
+            "$schema" => "http://json-schema.org/draft-04/schema#",
+            "items"   => [
+              {"type" => "integer"},
+              {"type" => "string"},
+            ],
+            "additionalItems" => false,
+          }}
+        end
+      end
+
+      context "given property" do
+        it_behaves_like JSON::Fuzz::Generator do
+          let(:schema) {{
+            "$schema" => "http://json-schema.org/draft-04/schema#",
+            "items"   => [
+              {"type" => "integer"},
+              {"type" => "string"},
+            ],
+            "additionalItems" => {"type" => "integer"},
+          }}
+        end
+      end
+    end
+  end
+
+  xcontext "self reference" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#",
+        "type"       => "object",
+        "properties" => {
+          "a" => {"type" => "integer"},
+          "b" => {"$ref" => "#"},
+        },
+      }}
+    end
+  end
+
+  %w[ip-address ipv6 time date date-time uri].each do |format|
+    context "format #{format}" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#",
+          "type"       => "object",
+          "properties" => {
+            "a" => {
+              "type"   => "string",
+              "format" => format,
+            },
+          },
+        }}
+      end
+    end
+  end
+
+  context "format with union types" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#",
+        "type"       => "object",
+        "properties" => {
+          "a" => {
+            "type"   => ["string", "null"],
+            "format" => "ip-address",
+          },
+        },
+      }}
+    end
+  end
+
+  context "dependencies" do
+    context "given single property" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#",
+          "type"       => "object",
+          "properties" => {
+            "a" => {"type" => "integer"},
+            "b" => {"type" => "integer"},
+          },
+          "dependencies" => {"a" => ["b"]},
+        }}
+      end
+    end
+
+    context "given multiple properties" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#",
+          "type"       => "object",
+          "properties" => {
+            "a" => {"type" => "integer"},
+            "b" => {"type" => "integer"},
+          },
+          "dependencies" => {"a" => ["b", "c"]},
+        }}
+      end
+    end
+  end
+
+  context "default" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#",
+        "type"       => "object",
+        "properties" => {
+          "a" => {"type" => "integer", "default" => 22},
+          "b" => {"type" => "integer"},
+        },
+      }}
+    end
+
+    context "with readonly" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#",
+          "type"       => "object",
+          "properties" => {
+            "a" => {"type" => "integer", "default" => 22, "readonly" => true},
+            "b" => {"type" => "integer"},
+          },
+        }}
+      end
+    end
+  end
+
+  %w[allOf anyOf oneOf].each do |keyword|
+    context keyword do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema" => "http://json-schema.org/draft-04/schema#",
+          keyword   => [
+            {
+              "properties" => {"a" => {"type" => "string"}},
+              "required"   => ["a"],
+            },
+            {
+              "properties" => {"b" => {"type" => "integer"}},
+            },
+          ]
+        }}
+      end
+    end
+  end
+
+  context "not" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"    => "http://json-schema.org/draft-04/schema#",
+        "properties" => {
+          "a" => {"not" => {"type" => ["string", "boolean"]}},
+        },
+      }}
+    end
+
+    context "with sub schema" do
+      it_behaves_like JSON::Fuzz::Generator do
+        let(:schema) {{
+          "$schema"    => "http://json-schema.org/draft-04/schema#",
+          "properties" => {"a" => {"not" => {"anyOf" => [
+            {"type" => ["string", "boolean"]},
+            {"type" => "object", "properties" => {"b" => {"type" => "boolean"}}},
+          ]}}},
+        }}
+      end
+    end
+  end
+
+  xcontext "definitions" do
+    it_behaves_like JSON::Fuzz::Generator do
+      let(:schema) {{
+        "$schema"     => "http://json-schema.org/draft-04/schema#",
+        "type"        => "array",
+        "items"       => {"$ref" => "#/definitions/positiveInteger"},
+        "definitions" => {
+          "positiveInteger" => {
+            "type"             => "integer",
+            "minimum"          => 0,
+            "exclusiveMinimum" => true,
+          },
+        },
+      }}
+    end
+  end
+end