easy_json_matcher 0.2.2 → 0.3.0

data/lib/easy_json_matcher/schema_generator.rb~

@@ -1,104 +0,0 @@
-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/string_validator.rb

@@ -1,16 +0,0 @@
-require 'easy_json_matcher/validator'
-module EasyJSONMatcher
-
-  class StringValidator < Validator
-
-    def _validate
-      # Could possible have a meta-method here that takes a list of symbols representing validator names
-      # and executes them in the validator of self.
-      _content_is_a_string?
-    end
-
-    def _content_is_a_string?
-      errors << "#{content} is not a String" unless content.is_a? String
-    end
-  end
-end

data/lib/easy_json_matcher/validator.rb~

@@ -1,99 +0,0 @@
-module EasyJSONMatcher
-  class Validator
-
-    attr_reader :content, :required, :errors, :custom_validator
-    attr_accessor :key
-
-    def initialize(options: {})
-      @key = options[:key]
-      @required = options[:required]
-      @custom_validator = options[:custom_validator]
-      @errors = []
-      _post_initialise(options)
-    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 = {}
-      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
-    end
-
-    def _no_errors?
-      errors.empty?
-    end
-  end
-end

data/lib/easy_json_matcher/validator_factory.rb

@@ -1,76 +0,0 @@
-require 'easy_json_matcher/object_validator'
-require 'easy_json_matcher/string_validator'
-require 'easy_json_matcher/number_validator'
-require 'easy_json_matcher/date_validator'
-require 'easy_json_matcher/boolean_validator'
-require 'easy_json_matcher/array_validator'
-require 'easy_json_matcher/value_validator'
-module EasyJSONMatcher
-  class ValidatorFactory
-
-    class << self
-      def get_instance(type:, opts: {})
-        raise "Type must be specified" unless type
-        if type == :schema
-          SchemaLibrary.get_schema(name: opts[:name], opts: opts)
-        else
-          validator_class = get_type(type)
-          validator_class.new options: opts
-        end
-      end
-
-      def get_type(name)
-        case name
-        when nil
-          default_validator
-        when :object
-          object_validator
-        when :string
-          string_validator
-        when :number
-          number_validator
-        when :date
-          date_validator
-        when :boolean
-          boolean_validator
-        when :array
-          array_validator
-        when :value
-          value_validator
-        end
-      end
-
-      def default_validator
-        value_validator
-      end
-
-      def object_validator
-        ObjectValidator
-      end
-
-      def string_validator
-        StringValidator
-      end
-
-      def number_validator
-        NumberValidator
-      end
-
-      def date_validator
-        DateValidator
-      end
-
-      def boolean_validator
-        BooleanValidator
-      end
-
-      def array_validator
-        ArrayValidator
-      end
-
-      def value_validator
-        ValueValidator
-      end
-    end
-  end
-end

data/lib/easy_json_matcher/value_validator.rb

@@ -1,10 +0,0 @@
-require 'easy_json_matcher/validator'
-module EasyJSONMatcher
-  
-  class ValueValidator < Validator
-
-    def _validate
-      true
-    end
-  end
-end

data/lib/easy_json_matcher/version.rb~

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

data/test/custom_validations_test.rb~

@@ -1,25 +0,0 @@
-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

@@ -1,262 +0,0 @@
-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