json-fuzz-generator 0.0.1

data/lib/json/fuzz/generator/keyword/all_of.rb

@@ -0,0 +1,46 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class AllOf 
+          class << self
+            def invalid_params(attributes)
+              all_of = attributes["allOf"]
+              raise "No allOf keyword given: #{attributes}" unless all_of
+
+              generated_params = []
+
+              all_of.each do |schema|
+                JSON::Fuzz::Generator.generate(schema).each do |invalid_param|
+                  if invalid_param.empty?
+                    generated_params << invalid_param
+                  else
+                    template = valid_param(attributes)
+                    template.merge!(invalid_param)
+                    generated_params << template
+                  end
+                end
+              end
+
+              generated_params
+            end
+
+            def valid_param(attributes)
+              attributes = Marshal.load(Marshal.dump(attributes))
+              all_of = attributes.delete("allOf")
+              raise "No allOf keyword given: #{attributes}" unless all_of
+              
+              generated_param = {}
+
+              all_of.each do |schema|
+                generated_param.merge!(JSON::Fuzz::Generator.default_param(schema))
+              end
+
+              generated_param
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/fuzz/generator/keyword/any_of.rb

@@ -0,0 +1,43 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class AnyOf 
+          class << self
+            def invalid_params(attributes)
+              any_of = attributes["anyOf"]
+              raise "No anyOf keyword given: #{attributes}" unless any_of
+
+              generated_params = []
+
+              any_of.each do |schema|
+                temp_params = JSON::Fuzz::Generator.generate(schema).reject do |param|
+                  ::JSON::Validator.validate(attributes, param)
+                end
+                temp_params.each {|e| generated_params << e}
+              end
+
+              raise "failed to generate invalid_params for schema: #{attributes}" if generated_params.empty?
+              generated_params.uniq
+            end
+
+            def valid_param(attributes)
+              attributes = Marshal.load(Marshal.dump(attributes))
+              any_of = attributes.delete("anyOf")
+              raise "No anyOf keyword given: #{attributes}" unless any_of
+              
+              generated_params = []
+
+              any_of.each do |valid_schema|
+                generated_param = JSON::Fuzz::Generator.default_param(valid_schema)
+                generated_params << generated_param
+              end
+
+              generated_params.sample
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/fuzz/generator/keyword/dependencies.rb

@@ -0,0 +1,49 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class Dependencies
+          class << self
+            def invalid_params(attributes)
+              attributes = Marshal.load(Marshal.dump(attributes))
+              dependencies = attributes.delete("dependencies")
+              raise "No dependencies keyword given: #{attributes}" unless dependencies
+
+              generated_params = []
+              template = JSON::Fuzz::Generator.default_param(attributes)
+              
+              dependencies.each do |key, dependency|
+                dependency.each do |required_key|
+                  invalid_param = Marshal.load(Marshal.dump(template))
+                  invalid_param.delete(required_key)
+                  generated_params << invalid_param
+                end
+              end
+
+              generated_params
+            end
+
+            def valid_param(attributes)
+              attributes = Marshal.load(Marshal.dump(attributes))
+              dependencies = attributes.delete("dependencies")
+              raise "No dependencies keyword given: #{attributes}" unless dependencies
+              
+              generated_params = []
+
+              dependencies.each do |key, dependency|
+                template = JSON::Fuzz::Generator.default_param(attributes)
+                template[key] = "hoge" if template.keys.size == 0
+                dependency.each do |required_key|
+                  template.merge!(required_key => template[template.keys.sample]) unless template.key?(required_key)
+                  generated_params << template
+                end
+              end
+
+              generated_params.sample
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/fuzz/generator/keyword/enum.rb

@@ -0,0 +1,33 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class Enum
+          class << self
+            def invalid_params(attributes)
+              attributes = Marshal.load(Marshal.dump(attributes))
+              enum = attributes.delete("enum")
+              raise "No enum keyword given: #{attributes}" unless enum
+
+              generated_params = []
+              JSON::Fuzz::Generator::PrimitiveType.type_to_class_map.each do |type, klass|
+                klass.invalid_params(attributes).each do |invalid_param|
+                  generated_params << invalid_param unless enum.include?(invalid_param)
+                end
+              end
+
+              generated_params.empty? ? [nil] : generated_params
+            end
+
+            def valid_param(attributes)
+              enum = attributes["enum"]
+              raise "No enum keyword given: #{attributes}" unless enum
+
+              enum.sample
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/fuzz/generator/keyword/format.rb

@@ -0,0 +1,93 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class Format
+          class << self
+            def invalid_params(attributes)
+              format  = attributes["format"]
+              raise "No format keyword given: #{attributes}" unless format
+
+              if invalid_params = format_to_invalid_params(format)
+                return 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)
+                return valid_params.sample
+              else
+                raise "invalid format type: #{attributes}"
+              end
+            end
+
+            private
+            def format_to_invalid_params(format)
+              {
+                "ip-address" => [
+                  "1.1.1", "1.1.1.300", 5, 
+                  "1.1.1", "1.1.1.1b",  "b1.1.1.1"
+                ],
+                "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",
+                ],
+                "time" => [
+                  "12:00",   "12:00:60",  "12:60:00", "24:00:00",
+                  "0:00:00", "-12:00:00", "12:00:00b"
+                ],
+                "date" => [
+                  "2010-01-32", "n2010-01-01", "2010-1-01", 
+                  "2010-01-1",  "2010-01-01n"
+                ],
+                "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-01T12:00:00z",
+                  "2010-01-0112:00:00Z",
+                ],
+                "uri" => [
+                  "::hoge",
+                ],
+                "email" => [
+                  "@example.com",
+                  "hoge",
+                  "http://example.com",
+                ],
+              }[format]
+            end
+            
+            def format_to_valid_params(format)
+              {
+                "ip-address" => ["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",
+                ],
+                "time" => ["12:00:00"],
+                "date" => ["1992-06-27"],
+                "date-time" => [
+                  "2010-01-01T12:00:00Z",
+                  "2010-01-01T12:00:00.1Z",
+                  "2010-01-01T12:00:00,1Z",
+                  "2010-01-01T12:00:00+0000",
+                  "2010-01-01T12:00:00+00:00",
+                ],
+                "uri" => ["http://gitbuh.com"],
+                "email" => ["hoge@example.com"],
+              }[format]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/fuzz/generator/keyword/items.rb

@@ -0,0 +1,68 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class Items
+          class << self
+            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 = []
+                JSON::Fuzz::Generator.generate(items).each do |invalid_item|
+                  invalid_param << invalid_item
+                end
+                generated_params << invalid_param
+              else
+                invalid_param = []
+                items.each do |item|
+                  JSON::Fuzz::Generator.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 << JSON::Fuzz::Generator.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 = JSON::Fuzz::Generator.default_param(items)
+              else
+                items.each do |item|
+                  generated_param << JSON::Fuzz::Generator.default_param(item)
+                end
+              end
+
+              generated_param
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/fuzz/generator/keyword/max_items.rb

@@ -0,0 +1,44 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class MaxItems
+          class << self
+            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 = JSON::Fuzz::Generator.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 << JSON::Fuzz::Generator.default_param(attributes)
+              end
+
+              generated_param
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/fuzz/generator/keyword/max_length.rb

@@ -0,0 +1,29 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class MaxLength
+          class << self
+            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)
+
+              return 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
+end

data/lib/json/fuzz/generator/keyword/max_properties.rb

@@ -0,0 +1,44 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class MaxProperties
+          class << self
+            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 = JSON::Fuzz::Generator.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
+end