json-fuzz-generator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 30a39a73a5cf80278262d3256ebb21cf148cf8f3
+  data.tar.gz: 07a5db01c606abf3f00702cfbfad86f6df46d8fd
+SHA512:
+  metadata.gz: f1ca3a27181a14ef2297b670f4c9742b0ae82bc46b5f09e67c093331dd01f9b42e2db6f676ff3091f747228c1f7c9b35a1e3fe130c6acb61a2c71e562fb7d4c0
+  data.tar.gz: 967c4a4f35a5a3fcbe26ab9e6ce722f25679d7d27ca01780a669f92ab5fdf58c7204a67445d871ce4a92b697e35f4fd831e2f3006810050e6b1c8519a522bb86

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.1.1
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fuzz-json-schema.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Naoki Shimizu
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,100 @@
+# JSON::Fuzz::Generator
+
+Fuzzing Parameter Generator from JSON Schema
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'json-fuzz-generator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install json-fuzz-generator
+
+## Usage
+
+### input JSON Schema
+
+```json:input_schema.json
+{
+  "title": "Basic Schema",
+  "type": "object",
+  "properties": {
+    "id" : {
+      "type": "integer",
+      "minimum": 0
+    },
+    "name": {
+      "type": "string"
+    },
+    "birthday": {
+      "type": "string",
+      "format": "date"
+    }
+  }
+}
+```
+### generate valid param
+
+```ruby
+require "json-fuzz-generator"
+ 
+JSON::Fuzz::Generator.default_param(schema_file)
+# => {"id"=>0, "name"=>"hoge", "birthday"=>"1992-06-27"}
+```
+### generate invalid params
+
+```ruby
+require "json-fuzz-generator"
+ 
+JSON::Fuzz::Generator.generate(schema_file)
+# => 
+#[
+#  ["sample", "array"],
+#  true,
+#  73,
+#  nil,
+#  0.34259093948835795,
+#  "hoge",
+#  {"id"=>"a", "name"=>"hoge", "birthday"=>"1992-06-27"},
+#  {"id"=>"1", "name"=>"hoge", "birthday"=>"1992-06-27"},
+#  {"id"=>0.1, "name"=>"hoge", "birthday"=>"1992-06-27"},
+#  {"id"=>["sample", "array"], "name"=>"hoge", "birthday"=>"1992-06-27"},
+#  {"id"=>false, "name"=>"hoge", "birthday"=>"1992-06-27"},
+#  {"id"=>nil, "name"=>"hoge", "birthday"=>"1992-06-27"},
+#  {"id"=>0.0, "name"=>"hoge", "birthday"=>"1992-06-27"},
+#  {"id"=>{}, "name"=>"hoge", "birthday"=>"1992-06-27"},
+#  {"id"=>"hoge", "name"=>"hoge", "birthday"=>"1992-06-27"},
+#  {"id"=>-1, "name"=>"hoge", "birthday"=>"1992-06-27"},
+#  {"id"=>0, "name"=>["sample", "array"], "birthday"=>"1992-06-27"},
+#  {"id"=>0, "name"=>true, "birthday"=>"1992-06-27"},
+#  {"id"=>0, "name"=>97, "birthday"=>"1992-06-27"},
+#  {"id"=>0, "name"=>nil, "birthday"=>"1992-06-27"},
+#  {"id"=>0, "name"=>0.7547537108664406, "birthday"=>"1992-06-27"},
+#  {"id"=>0, "name"=>{}, "birthday"=>"1992-06-27"},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>["sample", "array"]},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>false},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>11},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>nil},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>0.5380909041403419},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>{}},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>"2010-01-32"},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>"n2010-01-01"},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>"2010-1-01"},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>"2010-01-1"},
+#  {"id"=>0, "name"=>"hoge", "birthday"=>"2010-01-01n"},
+#]
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/deme0607/json-fuzz-generator/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/json-fuzz-generator.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'json/fuzz/generator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "json-fuzz-generator"
+  spec.version       = JSON::Fuzz::Generator::VERSION
+  spec.authors       = ["deme0607"]
+  spec.email         = ["hcs0035@gmail.com"]
+  spec.summary       = %q{Fuzz parameter gemerator from json-schema}
+  spec.description   = %q{Fuzz parameter gemerator from json-schema}
+  spec.homepage      = "https://github.com/deme0607/json-fuzz-generator"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "json-schema"
+  spec.add_dependency "randexp"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry-byebug"
+end

data/lib/json-fuzz-generator.rb

@@ -0,0 +1,5 @@
+require "json-schema"
+require "randexp"
+require "json/fuzz/generator"
+
+#Dir[File.join(File.dirname(__FILE__), "json/fuzz/generator/*.rb")].each {|file| require file }

data/lib/json/fuzz/generator.rb

@@ -0,0 +1,160 @@
+module JSON
+  module Fuzz
+    module Generator
+      Dir[File.join(File.dirname(__FILE__), "generator/*.rb")].each {|file| require file }
+
+      extend self
+      def generators(type)
+        generator_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,
+        }
+
+        if generator_map.key?(type)
+          return generator_map[type]
+        else
+          raise "no generator for #{type}"
+        end
+  j   end
+
+      def generate(schema)
+        schema = ::JSON::Validator.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).valid_param("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")
+          JSON::Fuzz::Generator::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")
+          JSON::Fuzz::Generator::Keyword::Not.invalid_params(schema).each do |invalid_param|
+            generated_params << invalid_param
+          end
+        else
+          raise "Not impremented generator for schema:#{schema}"
+        end
+
+        generated_params
+      end
+
+      def default_param(schema)
+        schema = ::JSON::Validator.parse(open(schema).read) if schema.instance_of?(String)
+        generated_param = nil;
+
+        if type = schema["type"]
+          type = type.sample if type.instance_of?(Array)
+          type = all_types.sample if type == "any"
+          generated_param = generators(type).valid_param(schema)
+        elsif schema.key?("properties")
+          generated_param = generators("object").valid_param(schema)
+        elsif schema.empty?
+          type, generator = JSON::Fuzz::Generator::PrimitiveType.type_to_class_map.to_a.sample
+          generated_param = generator.valid_param
+        elsif (schema.key?("minimum") || schema.key?("maximum"))
+          generated_param = generators("number").valid_param(schema)
+        elsif (schema.key?("minItems") || schema.key?("maxItems"))
+          generated_param = generators("array").valid_param(schema)
+        elsif (schema.key?("minProperties") || schema.key?("maxProperties"))
+          generated_param = generators("object").valid_param(schema)
+        elsif schema.key?("uniqueItems")
+          generated_param = generators("array").valid_param(schema)
+        elsif schema.key?("pattern")
+          generated_param = generators("string").valid_param(schema)
+        elsif (schema.key?("minLength") || schema.key?("maxLength"))
+          generated_param = generators("string").valid_param(schema)
+        elsif schema.key?("enum")
+          generated_param = JSON::Fuzz::Generator::Keyword::Enum.valid_param(schema)
+        elsif schema.key?("multipleOf")
+          generated_param = generators("number").valid_param(schema)
+        elsif schema.key?("items")
+          generated_param = generators("array").valid_param(schema)
+        elsif schema.key?("$ref")
+          raise "not impremented yet"
+        elsif schema.key?("allOf")
+          generated_param = JSON::Fuzz::Generator::Keyword::AllOf.valid_param(schema)
+        elsif schema.key?("anyOf")
+          generated_param = JSON::Fuzz::Generator::Keyword::AnyOf.valid_param(schema)
+        elsif schema.key?("oneOf")
+          generated_param = JSON::Fuzz::Generator::Keyword::OneOf.valid_param(schema)
+        elsif schema.key?("not")
+          generated_param = JSON::Fuzz::Generator::Keyword::Not.valid_param(schema)
+        else
+          raise "Not impremented generator for schema:#{schema}"
+        end
+
+        generated_param
+      end
+
+      private
+      def all_types
+        %w[array boolean integer null number object string]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword 
+        Dir[File.join(File.dirname(__FILE__), "keyword/*.rb")].each {|file| require file }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module JSON
+  module Fuzz
+    module Generator
+      class Keyword
+        class AdditionalProperties
+          class << self
+            def invalid_params(attributes)
+              attributes = Marshal.load(Marshal.dump(attributes))
+              additional_properties = attributes.delete("additionalProperties")
+              raise "No additionalProperties keyword given: #{attributes}" if additional_properties.nil?
+
+              template = JSON::Fuzz::Generator.default_param(attributes)
+
+              additional_key = nil
+              until (additional_key)
+                key = /\w+/.gen
+                additional_key = key unless template.key?(key)
+              end
+
+              if additional_properties
+                additional_param = JSON::Fuzz::Generator.generate(additional_properties).sample
+                template[additional_key] = additional_param
+              else
+                template[additional_key] = template[template.keys.sample]
+              end
+
+              [template]
+            end
+            
+            def valid_param(attributes)
+              attributes = Marshal.load(Marshal.dump(attributes))
+              additional_properties = attributes.delete("additionalProperties")
+              raise "No additionalProperties keyword given: #{attributes}" if additional_properties.nil?
+
+              template = JSON::Fuzz::Generator.default_param(attributes)
+
+              if additional_properties
+                additional_param = nil
+                if additional_properties.instance_of?(Hash)
+                  additional_param = JSON::Fuzz::Generator.default_param(additional_properties)
+                else
+                  additional_param = template[template.keys.sample]
+                end
+
+                additional_key = nil
+                until (additional_key)
+                  key = /\w+/.gen
+                  additional_key = key unless template.key?(key)
+                end
+
+                template[additional_key] = additional_param
+              end
+
+              template
+            end
+          end
+        end
+      end
+    end
+  end
+end