json-fuzz-generator 0.0.1

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

@@ -0,0 +1,46 @@
+module JSON
+  module Fuzz
+    module Generator
+      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
+
+              return 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"]
+                  return Random.rand(minimum_value...maximum_value)
+                else
+                  return Random.rand(minimum_value..maximum_value)
+                end
+              else
+                return maximum_value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module JSON
+  module Fuzz
+    module Generator
+      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 << JSON::Fuzz::Generator.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 = JSON::Fuzz::Generator.default_param(attributes)
+                item = "null" if item.nil?
+                generated_param << "null"
+              end
+
+              generated_param
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,39 @@
+module JSON
+  module Fuzz
+    module Generator
+      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 = JSON::Fuzz::Generator.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
+end

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

@@ -0,0 +1,45 @@
+module JSON
+  module Fuzz
+    module Generator
+      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
+
+              return 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"]
+                  return Random.rand(minimum_value...maximum_value)
+                else
+                  return Random.rand(minimum_value..maximum_value)
+                end
+              else
+                return minimum_value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module JSON
+  module Fuzz
+    module Generator
+      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
+end

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

@@ -0,0 +1,28 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class Not
+          class << self
+            def invalid_params(attributes)
+              not_attribute = attributes["not"]
+              raise "No not keyword given: #{attributes}" unless not_attribute
+
+              [JSON::Fuzz::Generator.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 = JSON::Fuzz::Generator.generate(not_attribute)
+
+              generated_params.sample
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class OneOf 
+          class << self
+            def invalid_params(attributes)
+              one_of = attributes["oneOf"]
+              raise "No oneOf keyword given: #{attributes}" unless one_of
+
+              generated_params = []
+
+              one_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)
+              one_of = attributes["oneOf"]
+              raise "No oneOf keyword given: #{attributes}" unless one_of
+
+              generated_params = []
+
+              one_of.each do |schema|
+                temp_params = JSON::Fuzz::Generator.generate(schema).select 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.sample
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class Pattern 
+          class << self
+            def invalid_params(attributes)
+              raise "not impremented"
+            end
+
+            def valid_param(attributes)
+              raise "not impremented"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module JSON
+  module Fuzz
+    module Generator
+      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|
+                JSON::Fuzz::Generator.generate(attribute).each do |invalid_param|
+                  template = JSON::Fuzz::Generator.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] = JSON::Fuzz::Generator.default_param(attribute)
+              end
+
+              generated_param
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module JSON
+  module Fuzz
+    module Generator
+      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 = JSON::Fuzz::Generator.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] = JSON::Fuzz::Generator.default_param(attribute)
+              end
+              
+              generated_param
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module JSON
+  module Fuzz
+    module Generator
+      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 
+              
+              JSON::Fuzz::Generator.generators("array").valid_param(attributes).uniq
+            end
+          end
+        end
+      end
+    end
+  end
+end