Create initial spec

fuzz-json-schema.gemspec

@@ -5,7 +5,7 @@ require 'fuzz/json/schema/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "fuzz-json-schema"
-  spec.version       = Fuzz::Json::Schema::VERSION
+  spec.version       = Fuzz::JSON::Schema::VERSION
   spec.authors       = ["deme0607"]
   spec.email         = ["hcs0035@gmail.com"]
   spec.summary       = %q{Fuzz parameter gemerator from json-schema}
@@ -21,4 +21,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "json-schema"
 end

lib/fuzz-json-schema.rb

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

lib/fuzz/json/generator.rb

@@ -0,0 +1,54 @@
+module Fuzz
+  module JSON
+    class Generator
+      class << self
+        def generate(json_schema)
+          generator = Fuzz::JSON::Generator.new
+          generator.generate(json_schema)
+        end
+      end
+
+      attr_accessor :generators
+
+      def initialize
+        @generators = {
+          "array"   => Fuzz::JSON::Generator::PrimitiveType::Array.new,
+          "boolean" => Fuzz::JSON::Generator::PrimitiveType::Boolean.new,
+          "integer" => Fuzz::JSON::Generator::PrimitiveType::Integer.new,
+          "null"    => Fuzz::JSON::Generator::PrimitiveType::Null.new,
+          "number"  => Fuzz::JSON::Generator::PrimitiveType::Number.new,
+          "object"  => Fuzz::JSON::Generator::PrimitiveType::Object.new,
+          "string"  => Fuzz::JSON::Generator::PrimitiveType::String.new,
+        }
+      end
+
+      def generate(schema)
+        schema = ::JSON::Validator.parse(open(schema).read) if schema.instance_of?(String)
+        generated_params = []
+
+        if type = schema["type"]
+          @generators[type].invalid_params(schema, self).each do |invalid_param|
+            generated_params.push(invalid_param)
+          end
+        else
+          raise "No Type"
+        end
+
+        generated_params
+      end
+
+      def default_param(schema)
+        generated_param = nil;
+        schema = ::JSON::Validator.parse(open(schema).read) if schema.instance_of?(String)
+
+        if type = schema["type"]
+          generated_param = @generators[type].valid_param(schema, self)
+        else
+          raise "No Type"
+        end
+
+        generated_param
+      end
+    end
+  end
+end

lib/fuzz/json/generator/primitive_type.rb

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

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

@@ -0,0 +1,18 @@
+module Fuzz
+  module JSON
+    class Generator
+      class PrimitiveType
+        class Array
+          def invalid_params(attributes, generator)
+            [{}]
+          end
+
+          def valid_param(attributes, generator)
+            ["sample", "array"]
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,18 @@
+module Fuzz
+  module JSON
+    class Generator
+      class PrimitiveType
+        class Boolean
+          def invalid_params(attributes, generator)
+            ["true", "false", "1", "0"]
+          end
+
+          def valid_param(attributes, generator)
+            [true, false].sample
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,18 @@
+module Fuzz
+  module JSON
+    class Generator
+      class PrimitiveType
+        class Integer
+          def invalid_params(attributes, generator)
+            ["a", "1"]
+          end
+
+          def valid_param(attributes, generator)
+            rand(100)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,18 @@
+module Fuzz
+  module JSON
+    class Generator
+      class PrimitiveType
+        class Null
+          def invalid_params(attributes, generator)
+            ["nil", "0", "null", false, ""]
+          end
+
+          def valid_param(attributes, generator)
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,18 @@
+module Fuzz
+  module JSON
+    class Generator
+      class PrimitiveType
+        class Number
+          def invalid_params(attributes, generator)
+            ["0.1", "10", "hoge"]
+          end
+
+          def valid_param(attributes, generator)
+            rand
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,42 @@
+module Fuzz
+  module JSON
+    class Generator
+      class PrimitiveType
+        class Object
+          def invalid_params(attributes, generator)
+            generated_params = []
+
+            if (attributes.key?("members") || attributes.key?("properties"))
+              properties = attributes["members"] || attributes["properties"]
+              properties.each do |key, attribute|
+                generator.generate(attribute).each do |invalid_param|
+                  template = generator.default_param(attributes)
+                  generated_params.push(template.merge(key => invalid_param))
+                end
+              end
+            else
+              generated_params = [nil, []]
+            end
+
+            generated_params
+          end
+
+          def valid_param(attributes, generator)
+            generated_param = {}
+
+            if (attributes.key?("members") || attributes.key?("properties"))
+              properties = attributes["members"] || attributes["properties"]
+
+              properties.each do |key, attribute|
+                generated_param[key] = generator.default_param(attribute)
+              end
+            end
+
+            generated_param
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,18 @@
+module Fuzz
+  module JSON
+    class Generator
+      class PrimitiveType
+        class String
+          def invalid_params(attributes, generator)
+            [1]
+          end
+
+          def valid_param(attributes, generator)
+            "hoge"
+          end
+        end
+      end
+    end
+  end
+end
+

lib/fuzz/json/schema.rb

@@ -1,9 +1,6 @@
-require "fuzz/json/schema/version"
-
 module Fuzz
-  module Json
-    module Schema
-      # Your code goes here...
+  module JSON
+    class Schema
     end
   end
 end

lib/fuzz/json/schema/version.rb

@@ -1,6 +1,6 @@
 module Fuzz
-  module Json
-    module Schema
+  module JSON
+    class Schema
       VERSION = "0.0.1"
     end
   end

spec/fuzz/json/schema_spec.rb

@@ -1,11 +1,32 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Fuzz::Json::Schema do
-  it 'has a version number' do
-    expect(Fuzz::Json::Schema::VERSION).not_to be nil
+describe Fuzz::JSON do
+  context "basic features" do
+    it "works" do
+      schema_file = File.join(SPEC_SCHEMA_ROOT, "basic_schema.json")
+      fuzz_params_list = Fuzz::JSON::Generator.generate(schema_file)
+
+      fuzz_params_list.each do |params|
+        expect(params).to include("id", "name", "age")
+        result = JSON::Validator.validate(schema_file, params)
+        expect(result).to eq(false)
+      end
+    end
   end
 
-  it 'does something useful' do
-    expect(false).to eq(true)
+  context "primitive types" do
+    it "works" do
+      schema_file      = File.join(SPEC_SCHEMA_ROOT, "primitive_types.json")
+      generator        = Fuzz::JSON::Generator.new
+      default_param    = generator.default_param(schema_file)
+      fuzz_params_list = generator.generate(schema_file)
+
+      fuzz_params_list.each do |params|
+        expect(params).to include(*default_param.keys)
+        warn params
+        result = JSON::Validator.validate(schema_file, params)
+        expect(result).to eq(false)
+      end
+    end
   end
 end

spec/schemas/basic_schema.json

@@ -0,0 +1,17 @@
+{
+        "title": "Basic Schema",
+        "type": "object",
+        "properties": {
+                "id" : {
+                        "type": "integer"
+                },
+                "name": {
+                        "type": "string"
+                },
+                "age": {
+                        "description": "Age in years",
+                        "type": "integer",
+                        "minimum": 0
+                }
+        }
+}

spec/schemas/primitive_types.json

@@ -0,0 +1,35 @@
+{
+        "title": "Primitive Types Schema",
+        "type": "object",
+        "properties": {
+                "arrayKey": {
+                        "type": "array"
+                },
+                "booleanKey": {
+                        "type": "boolean"
+                },
+                "integerKey": {
+                        "type": "integer"
+                },
+                "numberKey": {
+                        "type": "number"
+                },
+                "nullKey": {
+                        "type": "null"
+                },
+                "objectKey": {
+                        "type": "object",
+                        "properties": {
+                          "nested_string": {
+                            "type": "string"
+                          },
+                          "nested_integer": {
+                            "type": "integer"
+                          }
+                        }
+                },
+                "stringKey": {
+                        "type": "string"
+                }
+        }
+}

spec/spec_helper.rb

@@ -1,2 +1,7 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require 'fuzz/json/schema'
+require 'fuzz-json-schema'
+require 'pry'
+require 'json-schema'
+
+SPEC_ROOT        = File.expand_path(File.dirname(__FILE__), ".")
+SPEC_SCHEMA_ROOT = File.join(SPEC_ROOT, "schemas")