easy_json_matcher 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8247cb3e9791930357fc71b2adccd2207722d96c
-  data.tar.gz: a016110a42e4c8b82b0b58e06b9c0a858d20af14
+  metadata.gz: 29eb515cf0aae680f37f2c881b061c8d56fa5cc0
+  data.tar.gz: 5f617e24d4270c30f26e6bed85692402adad047e
 SHA512:
-  metadata.gz: ac9579c176287786a0f09bfe575f9362aa9d3ab723cf8ad6a94c18f546be62ec7f7cb08c1e9052f888129c0547ff8c2c82706e6c52042eb6ebe490acea22549c
-  data.tar.gz: 79cf3770d9f3898dfec75acfff000133e88f2e636e7a9f2ec802fd9386995aad72c73c39836d6584518213b52f2060916a29f0eb570e508ae7857c071be24ecf
+  metadata.gz: 317e11578a3bd7420e88fa30ab294941a6d644a2303ecd2412cb2650973ed466ea565357455052bd0323acf4a1b30b4b9b63d89ce6b5266cb2205b09aadd6551
+  data.tar.gz: 5e12a27e3f4f436afec4951e26e8136df61662859a3b240c617b7c70d2d7aa891072724a976b1c6383334245446c654762b50da35652b88053feafb9c6b41ba9

data/lib/easy_json_matcher/node.rb

@@ -29,6 +29,7 @@ module EasyJSONMatcher
     end
 
     def reset!
+      @validity = true
       errors.clear
       validators.each(&:reset!)
     end

data/lib/easy_json_matcher/node.rb~

@@ -0,0 +1,121 @@
+require 'easy_json_matcher/validator_factory'
+require 'json'
+require 'easy_json_matcher/content_wrapper'
+module EasyJSONMatcher
+  class Node < Validator
+    include ContentWrapper
+
+    attr_reader :validators, :validity, :strict
+
+    def initialize(opts: {})
+      super(options: opts)
+      @validators = []
+      @validity = true
+    end
+
+    def add_validator(validator)
+      validators << validator
+    end
+
+    def _post_initialise(options)
+      @strict = options[:strict]
+    end
+
+    def _validate
+      _validate_strict_keyset
+      validators.each do |val|
+        @validity = false unless _use_validator val
+      end
+    end
+
+    def reset!
+      errors.clear
+      validators.each(&:reset!)
+    end
+
+    def _validate_strict_keyset
+      _validate_keyset if strict
+    end
+
+    def _validate_keyset
+      unexpected_keys = keys - _expected_keys
+      errors << "#{unexpected_keys} found in addition to expected keys" unless unexpected_keys.empty?
+    end
+
+    def _expected_keys
+      validators.each_with_object([]) do |validator, keyset|
+        keyset << validator.key
+      end
+    end
+
+    def _use_validator(validator)
+      validator.valid? self
+    end
+
+    def _get_content_for(key)
+      content[key]
+    end
+
+    def _get_validator_for(key)
+      validators[key]
+    end
+
+    def _set_content(candidate)
+      @content = _is_root? ? _prep_root_content(candidate) : candidate[key]
+    end
+
+    def _is_root?
+      key.nil?
+    end
+
+    def get_errors
+      child_errors = _collect_child_errors
+      _wrap_errors(child_errors)
+    end
+
+    def _collect_child_errors
+      validators.each_with_object({}) do |val, container|
+        container.merge!(val.get_errors)
+      end
+    end
+
+    def _wrap_errors(child_errors)
+      _add_local_errors_to child_errors
+      unless _is_root?
+        _wrap_child_errors(child_errors)
+      else
+        _root_errors(child_errors)
+      end
+    end
+
+    def _add_local_errors_to(child_errors)
+      child_errors.merge!({node_errors_: errors}) unless errors.empty?
+    end
+
+    def _wrap_child_errors(child_errors)
+      errors_wrapper = {}
+      errors_wrapper[key] = child_errors
+      errors_wrapper
+    end
+
+    def _root_errors(child_errors)
+      errors.length > 0 ? {root: errors} : child_errors
+    end
+
+    def _prep_root_content(candidate)
+       candidate.is_a?(String) ? _parse_and_verify_json(candidate) : candidate
+    end
+
+    def _parse_and_verify_json(json)
+      begin
+        JSON.parse(json)
+      rescue JSON::ParserError
+        errors << '#{json} is not a valid JSON String'
+      end
+    end
+
+    def _no_errors?
+      validity && errors.empty?
+    end
+  end
+end

data/lib/easy_json_matcher/schema_generator.rb

@@ -14,7 +14,7 @@ module EasyJSONMatcher
       yield self if block_given?
     end
 
-    def has_attribute(key:, opts: {}, custom_validator: nil)
+    def has_attribute(key:, opts: {})
       node.add_validator(_create_validator(key, opts))
     end
 

data/lib/easy_json_matcher/schema_generator.rb~

@@ -0,0 +1,104 @@
+require 'easy_json_matcher/validator_factory'
+require 'easy_json_matcher/node'
+require 'easy_json_matcher/schema_library'
+require 'easy_json_matcher/exceptions'
+module EasyJSONMatcher
+  class SchemaGenerator
+
+    attr_reader :node, :name, :options, :glob_opts
+
+    def initialize(opts: {}, global_opts: {})
+      @name = opts.delete(:key)
+      @options = opts
+      @glob_opts = global_opts
+      yield self if block_given?
+    end
+
+    def has_attribute(key:, opts: {})
+      node.add_validator(_create_validator(key, opts))
+    end
+
+    ################ Methods for adding specific attribute types ##############
+
+    def contains_node(key:, opts: {})
+      generator = _node_generator _validator_opts(key, opts)
+      yield generator if block_given?
+      node.add_validator generator.generate_schema
+    end
+
+    def has_boolean(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :boolean}))
+    end
+
+    def has_number(key: , opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :number}))
+    end
+
+    def has_date(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :date}))
+    end
+
+    def has_object(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :object}))
+    end
+
+    def has_value(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :value}))
+    end
+
+    def has_string(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :string}))
+    end
+
+    def contains_array(key:, opts: {})
+      opts = opts.merge!({type: :array})
+      array_validator = _create_validator(key, opts)
+      yield array_validator if block_given?
+      node.add_validator array_validator
+    end
+
+    def has_schema(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :schema}))
+    end
+
+    ################ Methods for generating the schema #########################
+
+    def generate_schema
+      node
+    end
+
+    def register(as:)
+      SchemaLibrary.add_schema(name: as, schema: generate_schema)
+      generate_schema
+    end
+
+    ################## Private methods #########################################
+
+    def _prep_schema_opts(schema_name, opts)
+      opts[:type] = :schema
+      opts[:name] = schema_name
+      opts
+    end
+
+    def _set_validator_key(validator, key)
+      validator.key = key
+    end
+
+    def _validator_opts(key, opts)
+      opts[:key] = key
+      glob_opts.merge(opts)
+    end
+
+    def _create_validator(key, opts)
+      ValidatorFactory.get_instance type: opts[:type], opts: _validator_opts(key, opts)
+    end
+
+    def _node_generator(opts = {})
+     self.class.new opts: opts, global_opts: glob_opts
+    end
+
+    def node
+      @node ||= Node.new(opts: _validator_opts(name, options))
+    end
+  end
+end

data/lib/easy_json_matcher/version.rb

@@ -1,3 +1,3 @@
 module EasyJSONMatcher
-  VERSION = "0.2.1".freeze
+  VERSION = "0.2.2".freeze
 end

data/test/custom_validations_test.rb

@@ -4,23 +4,22 @@ class CustomValidationsTest < ActiveSupport::TestCase
 
   test 'As a user, I want to be able to specify custom validations' do
     test_schema = EasyJSONMatcher::SchemaGenerator.new do |s|
-      s.has_string key: :a_string, opts: { custom_validator: ->(candidate) { "String did not say 'hi'" unless candidate == 'hi' } }
+      string_validator = ->(candidate) { "String did not say 'hi'" unless candidate == 'hi' }
+      s.has_string key: :a_string, opts: { custom_validator: string_validator }
     end.generate_schema
 
     should_not_validate = {
       a_string: 'go away'
     }.to_json
 
-    assert_not(test_schema.valid? should_not_validate)
+    assert_not(test_schema.valid?(should_not_validate))
 
     should_validate = {
       a_string: 'hi'
     }.to_json
 
-
     test_schema.reset!
 
     assert(test_schema.valid?(should_validate), test_schema.get_errors)
-
   end
 end

data/test/custom_validations_test.rb~

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class CustomValidationsTest < ActiveSupport::TestCase
+
+  test 'As a user, I want to be able to specify custom validations' do
+    test_schema = EasyJSONMatcher::SchemaGenerator.new do |s|
+      string_validator = ->(candidate) { "String did not say 'hi'" unless candidate == 'hi' }
+      s.has_string key: :a_string, opts: { custom_validator: string_validator }
+    end.generate_schema
+
+    should_not_validate = {
+      a_string: 'go away'
+    }.to_json
+
+    assert_not(test_schema.valid?(should_not_validate))
+
+    should_validate = {
+      a_string: 'hi'
+    }.to_json
+
+    test_schema.reset!
+
+    assert(test_schema.valid?(should_validate), test_schema.get_errors)
+  end
+end

data/test/easy_json_matcher_test.rb~

@@ -0,0 +1,262 @@
+require 'test_helper'
+require 'json'
+
+# This test suite covers the basic concept of validating that a value is a
+# certain type
+class EasyJSONMatcherTest < ActiveSupport::TestCase
+
+  test "As a user I want to create new Schemas to match JSON objects" do
+    # This test represents the minimum level of implementation required to create a
+    # working node.
+    test_schema = EasyJSONMatcher::SchemaGenerator.new { |schema|
+      schema.contains_node(key: :data) do |node|
+        node.has_attribute(key: :title, opts: {type: :string})
+      end
+    }.register(as: :test)
+
+    valid_json = {
+                   data: {
+                        'title'=> "here's a title"
+                        }
+                  }.to_json
+    assert(test_schema.valid? valid_json)
+  end
+
+  # The first thing the gem ought to do is to check that the JSON candidate is actually JSON
+  test "As a user, if the validation candidate cannot be parsed as JSON, the schema should not be valid" do
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|s|
+      s.has_number(key: :population_of_china_1970)
+    }.generate_schema
+
+    invalid_json = "'population_of_china_1970' 810000000"
+
+    assert_not(test_schema.valid? invalid_json)
+  end
+
+
+  test "As a user I want to be able to validate strings" do
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|schema|
+      schema.has_string(key: :string, opts: { required: :true})
+    }.generate_schema
+
+    valid_json = {
+      string: "Mrs Mogs Hamilton"
+    }.to_json
+
+    assert(test_schema.valid?(valid_json), 'String was not validated')
+
+    # There isn't really a clear case for the string validator picking up if a
+    # value is not intended to be a string since all json values are effectively
+    # strings, and how is the library to know if the client meant 16 to be passed
+    # as a number or as a string?
+    # invalid_json = {
+    #   string: 16
+    # }.to_json
+    #
+    # assert_not(test_schema.valid?(invalid_json), 'Number was validated as a string')
+  end
+
+
+  test "As a user I want to be able to validate numbers" do
+
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|schema|
+      schema.has_number(key: :number, opts: {required: :true})
+    }.generate_schema
+
+    valid_json = {
+      number: 5.55,
+    }.to_json
+
+    assert(test_schema.valid?(valid_json), "Number was not validated")
+
+    invalid_json = {
+      number: "hi"
+    }.to_json
+    assert_not(test_schema.valid?(invalid_json), "\"hi\" should not have been valid")
+
+    invalid_nil = {
+      number: nil
+    }.to_json
+    assert_not(test_schema.valid?(invalid_nil), "#{invalid_nil} should not have validated, or thrown an error")
+  end
+
+  test "As a user I want to be able to validate booleans" do
+
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|schema|
+      schema.has_boolean(key: :true)
+      schema.has_boolean(key: :false)
+    }.generate_schema
+
+    valid_json = {
+      true: true,
+      false: false
+    }.to_json
+
+    assert(test_schema.valid?(valid_json), "Boolean was not validated")
+
+    invalid_json = {
+      true: 1,
+      false: "wibble"
+    }.to_json
+
+    # byebug
+    assert_not(test_schema.valid?(invalid_json), "\"1\" and \"wibble\" are not valid boolean values")
+  end
+
+  test "As a user I want to be able to validate Array values" do
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|schema|
+      schema.has_attribute(key: :array, opts: {type: :array})
+    }.generate_schema
+
+    valid_json = {
+      array: []
+    }.to_json
+
+    assert(test_schema.valid?(valid_json), "Array was not validated")
+
+    invalid_json = {
+      array: 1
+    }.to_json
+
+    assert(!test_schema.valid?(invalid_json), "\"1\" is not a valid array value")
+  end
+
+  test "As a user I want to be able to validate date values" do
+    test_schema = EasyJSONMatcher::SchemaGenerator.new { |schema|
+      schema.has_date(key: :date)
+    }.generate_schema
+
+    valid_json = {
+      date: "2015-01-15"
+    }.to_json
+
+    assert(test_schema.valid?(valid_json), "Date was not validated")
+
+    not_a_date = 'Good Night Mr. Tom'
+    invalid_json = {
+      date: not_a_date
+    }.to_json
+
+    assert_not(test_schema.valid?(invalid_json), "\"#{not_a_date}\" should not have been validated as a date")
+  end
+
+  test "As a user I want to be able to use different types of date format" do
+    flunk "Implement me"
+  end
+
+  test "As a user I want to validate object values" do
+    test_schema = EasyJSONMatcher::SchemaGenerator.new { |schema|
+      schema.has_object(key: :object)
+    }.generate_schema
+
+    is_an_object = {}
+
+    valid_json = {
+      object: is_an_object
+    }.to_json
+
+    assert(test_schema.valid?(valid_json),"#{is_an_object} was not validated as an object" )
+
+    not_an_object = "Popular Music"
+
+    invalid_json = {
+      object: not_an_object
+    }.to_json
+
+    assert_not(test_schema.valid?(invalid_json), "#{not_an_object} should not have validated as an object")
+  end
+
+  # Refers to validation of a JSON value attribute. This one is slightly tricky
+  # though since attempting to access a Ruby Hash with a missing key will return
+  # nil. The ValueValidator (or indeed any Validator) will accept nil as a value
+  # when the value is not marked as required.
+  # ValueValidator we will be stuck because although the other Validator
+  # classes nil indicates a missing value, in the case of the ValueValidator null is
+  # a valid value and we just want to check that there is a key available.
+  test "As a user I want to validate json value attributes" do
+      test_schema = EasyJSONMatcher::SchemaGenerator.new {|schema|
+        schema.has_value(key: :array)
+        schema.has_value(key: :boolean)
+        schema.has_value(key: :date)
+        schema.has_value(key: :number)
+        schema.has_value(key: :object)
+        schema.has_value(key: :string)
+        schema.has_value(key: :null)
+      }.generate_schema
+
+
+      valid_json = {
+        array: [],
+        boolean: true,
+        date: Date.today,
+        number: 1.11,
+        object: {},
+        string: 'The Tenderness of Wolves',
+        null: nil
+      }.to_json
+
+      assert(test_schema.valid?(valid_json), 'Value did not validate')
+
+       # There is no 'negative' test for this validator at this stage, since
+       # the lack of a value does not mean the key is required. See the tests
+       # on required validation later on.
+  end
+
+  test "As a user I want to validate nested json objects" do
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|schema|
+      schema.has_attribute(key: :level_1_attribute, opts: {type: :number})
+      schema.contains_node(key: :level_2) do |n|
+        n.has_attribute(key: :level_2_attribute, opts: {type: :number})
+        n.contains_node(key: :level_3) do |n3|
+          n3.has_attribute(key: :level_3_attribute, opts: {type: :number})
+        end
+      end
+    }.generate_schema
+
+    valid_json = {
+      level_1_attribute: 1,
+      level_2:{
+        level_2_attribute: 2,
+        level_3:{
+          level_3_attribute: 3
+        }
+      }
+    }.to_json
+
+    assert(test_schema.valid?(valid_json), "Nested JSON was not correctly validated")
+  end
+
+  test "As a user, if I specify a node and the content is not a node, it should be invalid without raising an error" do
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|schema|
+      schema.has_attribute(key: :fish_name, opts: {type: :string, required: :true})
+      schema.contains_node(key: :scientific_name) do |n|
+        n.has_attribute(key: :genus, opts: {type: :string, required: :true})
+        n.has_attribute(key: :species, opts: {type: :string, required: :true})
+      end
+    }.generate_schema
+
+    valid_json = {
+      fish_name: 'Clownfish',
+      scientific_name: {
+        genus: 'Amphiprion',
+        species: 'ocellaris'
+      }
+    }.to_json
+
+    assert(test_schema.valid?(valid_json), "#{valid_json} should have been valid")
+
+    invalid_with_array = {
+      fish_name: 'Green Mandarin',
+      scientific_name: ['Synchiropus', 'splendidus']
+    }.to_json
+
+    assert_not(test_schema.valid?(invalid_with_array), "#{invalid_with_array} should not have been valid as it has an array instead of a node")
+
+    invalid_with_primitive = {
+      fish_name: 'Hawaiian Tang',
+      scientific_name: 'Zebrasoma flavescens'
+    }.to_json
+
+    assert_not(test_schema.valid?(invalid_with_primitive), "#{invalid_with_primitive} shoudl not have been valid as it has a primite instead of a node")
+  end
+end

data/test/reset_test.rb

@@ -19,6 +19,12 @@ class ResetTest < ActiveSupport::TestCase
 
     test_schema.reset!
 
+    valid_json = {
+      bool: true
+    }.to_json
+    
+    assert(test_schema.valid?(valid_json), test_schema.get_errors)
+
     errors = test_schema.get_errors
     assert errors[:node][:val].empty?
     assert errors[:bool].empty?

data/test/reset_test.rb~

@@ -0,0 +1,32 @@
+require 'test_helper'
+class ResetTest < ActiveSupport::TestCase
+
+  test 'As a user, I want to be able to reuse a validator' do
+    # In other words, after a valid? has been called, the error messages need to be cleared
+    test_schema = EasyJSONMatcher::SchemaGenerator.new(global_opts: { strict: true }) { |sc|
+      sc.has_boolean key: :bool, opts: { required: true }
+      sc.contains_node key: :node do |n|
+        n.has_value key: :val
+      end
+    }.generate_schema
+
+    invalid_json = {
+
+    }.to_json
+
+    assert_not(test_schema.valid?(invalid_json))
+    assert_not(test_schema.get_errors[:bool][0].nil?)
+
+    test_schema.reset!
+
+    valid_json = {
+      bool: true
+    }.to_json
+    
+    assert(test_schema.valid?(valid_json))
+
+    errors = test_schema.get_errors
+    assert errors[:node][:val].empty?
+    assert errors[:bool].empty?
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: easy_json_matcher
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - WJD Hamilton
@@ -27,9 +27,11 @@ files:
 - lib/easy_json_matcher/date_validator.rb
 - lib/easy_json_matcher/exceptions.rb
 - lib/easy_json_matcher/node.rb
+- lib/easy_json_matcher/node.rb~
 - lib/easy_json_matcher/number_validator.rb
 - lib/easy_json_matcher/object_validator.rb
 - lib/easy_json_matcher/schema_generator.rb
+- lib/easy_json_matcher/schema_generator.rb~
 - lib/easy_json_matcher/schema_library.rb
 - lib/easy_json_matcher/string_validator.rb
 - lib/easy_json_matcher/validation_error.rb
@@ -41,13 +43,16 @@ files:
 - lib/easy_json_matcher/version.rb~
 - lib/tasks/jsonapi_matcher_tasks.rake
 - test/custom_validations_test.rb
+- test/custom_validations_test.rb~
 - test/easy_json_matcher_test.rb
+- test/easy_json_matcher_test.rb~
 - test/error_messages_test.rb
 - test/global_validation_options_test.rb
 - test/json_api_home.txt
 - test/managing_schemas_test.rb
 - test/required_validation_test.rb
 - test/reset_test.rb
+- test/reset_test.rb~
 - test/strict_mode_test.rb
 - test/test_helper.rb
 - test/validating_arrays_test.rb
@@ -77,13 +82,16 @@ specification_version: 4
 summary: Easily test your JSON output with templates and Schemas
 test_files:
 - test/custom_validations_test.rb
+- test/custom_validations_test.rb~
 - test/easy_json_matcher_test.rb
+- test/easy_json_matcher_test.rb~
 - test/error_messages_test.rb
 - test/global_validation_options_test.rb
 - test/json_api_home.txt
 - test/managing_schemas_test.rb
 - test/required_validation_test.rb
 - test/reset_test.rb
+- test/reset_test.rb~
 - test/strict_mode_test.rb
 - test/test_helper.rb
 - test/validating_arrays_test.rb