easy_json_matcher 0.2.2 → 0.3.0

data/lib/easy_json_matcher/schema_library.rb

@@ -2,34 +2,31 @@ module EasyJSONMatcher
   class SchemaLibrary
 
     SCHEMAS = {}
+
     private_constant :SCHEMAS
+
     class << self
+
       def available_schemas
-        schemas.keys
+       SCHEMAS.keys
       end
 
       def schema_for(name)
-        schemas[name]
+       SCHEMAS[name]
       end
 
       def add_schema(name:, schema:)
-        schemas[name] = schema
-      end
-
-      def schemas
-        SCHEMAS
+       SCHEMAS[name] = schema
       end
 
       def get_schema(name:, opts: {})
-         schema = _find_and_clone_schema(name) or raise MissingSchemaException.new("No schema with #{name} has been registered")
-        _set_schema_key(schema, opts.delete(:key))
+        schema = _find_and_clone_schema(name) or raise MissingSchemaException.new("No schema with #{name} has been registered")
         schema
       end
 
       def _find_and_clone_schema(name)
         s = SCHEMAS[name]
-        return s.dup if s
-        nil
+        return s.dup if s or nil
       end
 
       def _set_schema_key(schema, key)

data/lib/easy_json_matcher/unknown_validation_step_error.rb

@@ -0,0 +1,10 @@
+require "easy_json_matcher/easy_json_matcher_error"
+
+module EasyJSONMatcher
+  class UnknownValidationStepError < EasyJSONMatcherError
+
+    def initialize(type)
+      super "No validator available for #{type}, consider using a custom validator"
+    end
+  end
+end

data/lib/easy_json_matcher/validation_chain_factory.rb

@@ -0,0 +1,48 @@
+require "easy_json_matcher/validation_step"
+require "easy_json_matcher/unknown_validation_step_error"
+require "easy_json_matcher/exceptions"
+
+module EasyJSONMatcher
+  class ValidationChainFactory
+
+    class << self
+
+      def get_chain(steps:, of: ValidationStep)
+        head = create_head_for(steps: steps, step_type: of)
+        assemble_chain(head: head, steps: steps, step_type: of)
+        head
+      end
+
+      def assemble_chain(head:, steps:, step_type:)
+        steps.inject(head) do |last_link, step|
+          last_link >> get_step_for(validating: step, using: step_type)
+        end
+      end
+
+      def create_head_for(steps:, step_type:)
+        is_required = steps.include?(:required)
+        get_step_for validating: is_required ? :required : :not_required, using: step_type
+      end
+
+      def get_step_for(validating:, using: ValidationStep)
+        if validating.respond_to? :call
+          using.new verify_with: validating
+        elsif verifier = standard_validator(with: validating)
+          using.new verify_with: verifier
+        else
+          begin
+           return SchemaLibrary.get_schema(name: validating)
+          rescue MissingSchemaException => ex
+            #TODO this needs a little finesse: How will the user know if it was a missing schema?
+            raise UnknownValidationStepError.new(type: validating)
+          end
+        end
+      end
+
+      def standard_validator(with:)
+        require "easy_json_matcher/validation_rules"
+        VALIDATION_RULES[with]
+      end
+    end
+  end
+end

data/lib/easy_json_matcher/validation_rules.rb

@@ -0,0 +1,59 @@
+module EasyJSONMatcher
+
+  VALIDATION_RULES = {
+    object: -> (value, errors) {
+    unless value.is_a? Hash
+      errors << "#{value} is not an Object"
+      return false
+    end
+  },
+    string: -> (value, errors) {
+    unless value.is_a? String
+      errors << "#{value} is not a String"
+      return false
+    end
+  },
+    number: -> (value, errors){
+    error_message = "#{value} is not a Number"
+    begin
+      Kernel::Float(value)
+    rescue ArgumentError, TypeError
+      errors << error_message
+      false
+    end
+  },
+    date: ->(value, errors){
+    require "date"
+    error_message = "#{value} is not a valid SQL date"
+    begin
+      Date.strptime(value,"%Y-%m-%d")
+    rescue ArgumentError, TypeError
+      errors << error_message
+    end
+  },
+    boolean: ->(value, errors){
+    clazz = value.class
+    unless (clazz == TrueClass) || (clazz == FalseClass)
+      errors << "#{value} is not a Boolean"
+      false
+    end
+  },
+    array: ->(value, errors){
+    unless value.is_a? Array
+      errors << "Value was not an array"
+      false
+    end
+  },
+    value: ->(value, errors){
+    # This is a bit of a toughie since value can be any value, including nil
+  },
+    not_required: ->(value, errors){
+    false if value.nil?
+  },
+    required: ->(value, errors){
+      errors << "no value found" and return false if value.nil?
+  }
+  }
+end
+
+

data/lib/easy_json_matcher/validation_step.rb

@@ -0,0 +1,36 @@
+# The ValidationStep class represents a step in the process of validating a value. Each ValidationStep
+# instance can be chained to another ValidationStep instance in order to produce a defined process for 
+# running validations within a given Validator. A use case for such a procedure is where a value is 
+# required and of a certain type. In this case the validation for required must precede the check for 
+# the type, and validation must cease if the value is nil. 
+module EasyJSONMatcher
+  class ValidationStep
+
+    attr_reader :next_step, :verifier
+
+    def initialize(verify_with:)
+      @verifier = verify_with
+    end
+
+    def check(value:)
+      errors = []
+      if verifier.call(value, errors) == false || is_tail?
+        errors
+      else
+        errors + next_step.check(value: value)
+      end
+    end
+
+    def >>(step)
+      @next_step = step
+    end
+
+    def concat(chain)
+      is_tail? ? self.>>(chain) : next_step.concat(chain)
+    end
+
+    def is_tail?
+      next_step.nil?
+    end
+  end
+end

data/lib/easy_json_matcher/validator.rb

@@ -1,102 +1,27 @@
+require 'easy_json_matcher/json_coercer'
+
 module EasyJSONMatcher
   class Validator
 
-    attr_reader :content, :required, :errors, :custom_validator
+    attr_reader :validation_chain, :coercer
     attr_accessor :key
 
-    def initialize(options: {})
-      @key = options[:key]
-      @required = options[:required]
-      @custom_validator = options[:custom_validator]
-      @errors = []
-      _post_initialise(options)
+    def initialize(validate_with:, coerce_with: JsonCoercer.new)
+      @validation_chain = validate_with
+      @coercer = coerce_with
     end
 
     # Hook. Allows further setup to be carried out by subclasses
     def _post_initialise(options); end
 
-    def valid?(candidate)
-      if key
-        return false unless _check_content_type(candidate)
-      end
-      _set_content(candidate) #Hook
-      if content.nil?
-         _check_required?
-      else
-        _validate #Hook
-      end
-      _run_custom_validator if custom_validator
-      _no_errors?
-    end
-
-    # Hook. Overriden in Node
-    def reset!
-      errors.clear
-    end
-
-    # Hook
-    # Protected method that Validators use to implement their validation logic.
-    # Called by #valid?
-    def _validate
-      raise NotImplementedError.new "Validators must override _validate"
-    end
-
-    # Hook
-    # Protected method that Validators use to set their content from the candidate.
-    def _set_content(candidate)
-      @content = key ? candidate[key] : candidate
-    end
-
-    # Hook.
-    # This method returns the errors that this validator has found in the candidate.
-    def get_errors
-      error_message = {}
-      # Should the method just add errors even if there has been no error? Would
-      # avoid undefined method [] for nil:NilClass if you look for a key where
-      # there is no error but it would also make the output harder to read...
-      error_message[key.to_sym] = errors
-      error_message
-    end
-
-    # This method makees sure that the candidate behaves like a Hash, and not a
-    # value or an array.
-    def _check_content_type(candidate)
-      # TODO perhaps this should raise an error instead of returning false?
-      # if the value that has arrived at this point doesn't behave like a Hash then it
-      # is in the wrong place.
-      begin
-        candidate[key]
-      rescue TypeError
-        return false
-      end
-      true
-    end
-
-    def _check_required?
-      if required
-        errors << "Value was not present"
-        return true
-      else
-        return false
-      end
-    end
-
-    def _create_validator(type:, opts: {})
-      ValidatorFactory.get_instance(type: type, opts: opts)
-    end
-
-    def _custom_validator?
-      custom_validator
-    end
-
-    def _run_custom_validator
-      if error_message = custom_validator.call(content)
-        errors << error_message
-      end
+    def valid?(candidate:)
+      errors = validate(candidate: candidate)
+      errors.empty?
     end
 
-    def _no_errors?
-      errors.empty?
+    def validate(candidate:)
+      candidate = coercer.coerce(json: candidate)
+      validation_chain.check(value: candidate)
     end
   end
 end

data/lib/easy_json_matcher/validator_set.rb

@@ -0,0 +1,31 @@
+require 'easy_json_matcher'
+
+module EasyJSONMatcher
+  class ValidatorSet
+
+    attr_accessor :validators, :strict
+
+    def initialize(validators:, strict: false)
+      @validators = validators
+      @strict = strict
+    end
+
+    def check(value:, errors:[])
+      error_hash = validators.each_with_object({}) do |k_v, errors_found|
+        key = k_v[0]
+        val = value[key]
+        validator = k_v[1]
+        results = validator.check(value: val)
+        errors_found[key] = results unless results.empty?
+      end
+      validate_strict_keyset(keys: validators.keys, candidates: value.keys, errors: error_hash) if strict
+      errors << error_hash unless error_hash.empty?
+      errors
+    end
+
+    def validate_strict_keyset(keys:, errors:, candidates:)
+      rogue_keys = candidates - keys
+      errors[:unexpected_keys] = "Unexpected keys: #{rogue_keys}" unless rogue_keys.empty?
+    end
+  end
+end

data/lib/easy_json_matcher/version.rb

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

data/lib/easy_json_matcher.rb

@@ -1,5 +1,9 @@
-require 'easy_json_matcher/node'
-require 'easy_json_matcher/schema_generator'
+require "easy_json_matcher/node"
+require "easy_json_matcher/schema_generator"
+require "easy_json_matcher/validator_set"
+
 module EasyJSONMatcher
 
+  TYPES = [:number, :object, :value, :string, :boolean, :date, :array]
+
 end

data/lib/easy_json_matcher.rb~

@@ -0,0 +1,5 @@
+require 'easy_json_matcher/node'
+require 'easy_json_matcher/schema_generator'
+module EasyJSONMatcher
+
+end

data/test/array_content_validator_test.rb

@@ -0,0 +1,17 @@
+require "test_helper"
+require "easy_json_matcher/array_content_validator"
+
+module EasyJSONMatcher
+  describe ArrayContentValidator do
+
+    it "should check all the elements in an array" do
+      mock_values = (1..5).map do |n| 
+        mock_val = Minitest::Mock.new
+        mock_val.expect(:hello, "hi")
+      end
+      subject = ArrayContentValidator.new( verify_with: ValidationStep.new(verify_with: ->(value, errors) { value.hello }))
+      subject.check value: mock_values
+      mock_values.each(&:verify)
+    end
+  end
+end

data/test/custom_validations_test.rb

@@ -1,25 +1,25 @@
 require 'test_helper'
 
-class CustomValidationsTest < ActiveSupport::TestCase
+module EasyJSONMatcher
 
-  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
+  describe "Custom Validations" do
 
-    should_not_validate = {
-      a_string: 'go away'
-    }.to_json
+    subject { 
+      SchemaGenerator.new { |sc|
+        sc.has_attribute key: :val, 
+          opts: [
+            :required,
+            ->(value, errors) { errors << "value was false" unless value === true }
+        ]
+      }.generate_schema
+    }
 
-    assert_not(test_schema.valid?(should_not_validate))
+    it "should pass where val => true" do
+      subject.validate( candidate: { val: true }.to_json ).must_be :empty?
+    end
 
-    should_validate = {
-      a_string: 'hi'
-    }.to_json
-
-    test_schema.reset!
-
-    assert(test_schema.valid?(should_validate), test_schema.get_errors)
+    it "should show an error where val => false" do
+      subject.validate( candidate: { val: false }.to_json ).wont_be :empty?
+    end
   end
 end

data/test/global_validation_options_test.rb

@@ -1,48 +1,43 @@
 require 'test_helper'
 
-class GlobalValidationOptionsTest < ActiveSupport::TestCase
-
-  test 'As a user I want to be able to set validation options globally when defining the schema' do
-
-    test_schema = EasyJSONMatcher::SchemaGenerator.new(global_opts: { required: true }) { |schema|
-      schema.has_boolean key: :implicitly_required
-      schema.contains_node key: :also_implicitly_required do |n|
-        n.has_boolean key: :nested_implicitly_required
-      end
-    }.generate_schema
-
-    invalid = {
-      also_implicitly_required: {
-      }
-    }.to_json
-
-    assert_not(test_schema.valid?invalid)
-    implicitly_required_error = test_schema.get_errors[:implicitly_required][0]
-    nested_implicitly_required_error = test_schema.get_errors[:also_implicitly_required][:nested_implicitly_required][0]
-    error_message = /Value was not present/
-    assert_match(error_message, implicitly_required_error)
-    assert_match(error_message, nested_implicitly_required_error)
-  end
-
-  test 'As a user I want to be able to override global validation options for specific node' do
-
-    test_schema = EasyJSONMatcher::SchemaGenerator.new(global_opts: { required: true }) { |schema|
-      schema.has_boolean key: :implicitly_required
-      schema.contains_node key: :also_implicitly_required do |n|
-        n.has_boolean key: :nested_implicitly_required, opts: {required: false}
-      end
-    }.generate_schema
-
-    invalid = {
-      also_implicitly_required: {
-      }
-    }.to_json
-
-    assert_not(test_schema.valid?invalid)
-    implicitly_required_error = test_schema.get_errors[:implicitly_required][0]
-    nested_implicitly_required_error = test_schema.get_errors[:also_implicitly_required][:nested_implicitly_required][0]
-    error_message = /Value was not present/
-    assert_match(error_message, implicitly_required_error)
-    assert(nested_implicitly_required_error.nil?)
+module EasyJSONMatcher
+
+  describe "Global Validation Options" do
+
+
+    subject {  
+      SchemaGenerator.new(global_opts: [ :required ]) { |schema|
+        schema.has_boolean key: :implicitly_required
+        schema.contains_node key: :also_implicitly_required do |n|
+          n.has_boolean key: :nested_implicitly_required
+          n.has_boolean key: :not_required, opts: [:not_required]
+        end
+      }.generate_schema
+    }
+
+    let(:invalid_candidate){
+      {
+        also_implicitly_required: {
+          nested_implicitly_required: true
+        }
+      }.to_json
+    }
+
+    let(:valid_candidate){
+      {
+        implicitly_required: true,
+        also_implicitly_required: {
+          nested_implicitly_required: true
+        }
+      }.to_json
+    }
+
+    it "should only apply required to all implicitly required keys" do
+      subject.valid?(candidate: valid_candidate).must_be :===, true
+    end
+
+    it "should apply required to all implicitly required keys" do
+      subject.valid?(candidate: invalid_candidate).must_be :===, false
+    end
   end
 end

data/test/json_coercer_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+require "easy_json_matcher/json_coercer"
+require "easy_json_matcher/coercion_error"
+
+module EasyJSONMatcher
+  describe JsonCoercer do
+
+    before do
+      @subject = JsonCoercer.new
+    end
+
+    describe "#coerce" do
+
+      it "should coerce a valid JSON string to a Hash" do
+        valid_json = { a: 1, b: 2, c: 3}.to_json
+        @subject.coerce(json: valid_json).must_be_instance_of Hash
+      end
+
+      it "should raise a JSONFormatError if json: is an invalid JSON string" do
+        invalid_json = "123"
+        -> { @subject.coerce(json: invalid_json) }.must_raise CoercionError
+      end
+    end
+  end
+end

data/test/managing_schemas_test.rb

@@ -1,68 +1,69 @@
-require 'test_helper'
+require "test_helper"
+require "easy_json_matcher/exceptions"
 
-class ManagingSchemasTest < ActiveSupport::TestCase
+module EasyJSONMatcher
+  class ManagingSchemasTest < ActiveSupport::TestCase
 
-  setup do
-    @name = :test
-    EasyJSONMatcher::SchemaGenerator.new { |schema|
-      schema.has_attribute(key: :name, opts: {type: :string, required: true})
-    }.register(as: @name)
-  end
-
-  test "As a user I want to be able to register a Schema so I can reuse it later" do
-    assert(EasyJSONMatcher::SchemaLibrary.available_schemas.include?(:test), ":test not found in available_nodes")
-  end
+    setup do
+      @name = :test
+      SchemaGenerator.new { |schema|
+        schema.has_attribute(key: :name, opts: [ :string, :required ])
+      }.register(as: @name)
+    end
 
-  test "As as user I want to reuse a saved schema"  do
-    test_schema = {
-      name: 'Green Mandarin'
-    }.to_json
+    test "As a user I want to be able to register a Schema so I can reuse it later" do
+      assert(SchemaLibrary.available_schemas.include?(:test), ":test not found in available_nodes")
+    end
 
-    schema = EasyJSONMatcher::SchemaLibrary.get_schema(name: @name)
-    assert(schema.valid?(test_schema), "test_schema did not validate correctly")
-  end
+    test "As as user I want to reuse a saved schema"  do
+      candidate = {
+        name: "Green Mandarin"
+      }.to_json
+      schema = Validator.new validate_with: SchemaLibrary.get_schema(name: @name)
+      assert(schema.valid?(candidate: candidate), "test_schema did not validate correctly")
+    end
 
-  test "SchemaLibrary should thrown a MissingSchemaException if an unregistered schema is requested" do
-    assert_raises(EasyJSONMatcher::MissingSchemaException) do
-      EasyJSONMatcher::SchemaLibrary.get_schema(name: "#{@name.to_s}-wibble")
+    test "SchemaLibrary should thrown a MissingSchemaException if an unregistered schema is requested" do
+      assert_raises(MissingSchemaException) do
+        SchemaLibrary.get_schema(name: "#{@name.to_s}-wibble")
+      end
     end
-  end
 
-  test "As a user I want to reuse a schema within another schema" do
-    test_schema = EasyJSONMatcher::SchemaGenerator.new { |s|
-      s.has_boolean(key: :is_present, opts: {required: true})
-      s.has_schema(key: @name, opts: {name: @name, required: true})
-    }.generate_schema
+    test "As a user I want to reuse a schema within another schema" do
+      test_schema = SchemaGenerator.new { |s|
+        s.has_boolean key: :is_present, opts: [ :required ]
+        s.has_schema key: @name, name: @name
+      }.generate_schema
 
-    invalid_json = {
-      is_present: true,
-    }
+      invalid_json = {
+        is_present: true,
+      }
 
-    # assert_not(test_schema.valid?(invalid_json), "#{invalid_json} should not have been valid as it does not include the saved schema")
+      # assert_not(test_schema.valid?(invalid_json), "#{invalid_json} should not have been valid as it does not include the saved schema")
 
-    valid_json = invalid_json.dup
-    valid_json.store(@name, {name: 'Achilles Tang'})
-    valid_json = valid_json.to_json
-    assert(test_schema.valid?(valid_json), "Stored schema did not validate correctly")
-  end
+      valid_json = invalid_json.dup
+      valid_json.store(@name, {name: "Achilles Tang"})
+      valid_json = valid_json.to_json
+      assert(test_schema.valid?(candidate: valid_json), "Stored schema did not validate correctly")
+    end
 
-  test "It can validate JSON Schema payloads" do
-    EasyJSONMatcher::SchemaGenerator.new { |country|
-      country.has_attribute key: :id,      opts: {type: :number, required: true}
-      country.contains_node(key: :attributes) do |atts|
-        atts.has_attribute key: :alpha_2,  opts: {type: :string, required: true}
-        atts.has_attribute key: :alpha_3,  opts: {type: :string, required: true}
-        atts.has_attribute key: :name,     opts: {type: :string, required: true}
-      end
-    }.register(as: :country)
+    test "It can validate JSON Schema payloads" do
+      SchemaGenerator.new { |country|
+        country.has_attribute key: :id, opts: [:number, :required]
+        country.contains_node(key: :attributes) do |atts|
+          atts.has_attribute key: :alpha_2,  opts: [ :string, :required ]
+          atts.has_attribute key: :alpha_3,  opts: [ :string, :required ]
+          atts.has_attribute key: :name,     opts: [ :string, :required ]
+        end
+      }.register(as: :country)
 
-    EasyJSONMatcher::SchemaGenerator.new {|country_payload|
-      country_payload.has_attribute(key: :data, opts: {name: :country, type: :schema})
-    }.register(as: :country_payload)
+      country_payload = SchemaGenerator.new {|country_payload|
+        country_payload.has_schema(key: :data, name: :country)
+      }.register(as: :country_payload)
 
-    valid_json = "{\"data\":{\"id\":\"4376\",\"type\":\"countries\",\"attributes\":{\"alpha_2\":\"GB\",\"alpha_3\":\"GBR\",\"name\":\"United Kingdom of Great Britain and Northern Ireland\"}}}"
+      valid_json = "{\"data\":{\"id\":\"4376\",\"type\":\"countries\",\"attributes\":{\"alpha_2\":\"GB\",\"alpha_3\":\"GBR\",\"name\":\"United Kingdom of Great Britain and Northern Ireland\"}}}"
 
-    validator = EasyJSONMatcher::SchemaLibrary.get_schema(name: :country_payload)
-    assert(validator.valid? valid_json)
+      assert country_payload.valid?(candidate: valid_json)
+    end
   end
 end