easy_json_matcher 0.2.2 → 0.3.0

data/test/node_test.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+require "easy_json_matcher/validation_chain_factory"
+
+module EasyJSONMatcher
+
+  describe Node do
+
+    describe "#add_validator" do
+
+      it "should respond to #check" do
+        Node.new(validators: nil).must_respond_to :check
+      end
+
+      it "should send call to its own validator" do
+        test_value = { a: 1, b: 2, c: 3 }
+        validators = (:a..:c).each_with_object({}) do |n, h|
+          h[n] = ValidationChainFactory.get_chain(steps: [:string])
+        end
+        node = Node.new(opts: [:required], validators: validators)
+        expected = [{a: ["1 is not a String"],
+                     b: ["2 is not a String"],
+                     c: ["3 is not a String"]
+        }]
+        node.check(value: test_value).must_be :==, expected
+      end
+    end
+  end
+end

data/test/primitives_boolean_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+require 'json'
+
+# This test suite covers the basic concept of validating that a value is a
+# certain type
+
+module EasyJSONMatcher
+
+  describe "Basic Type Validations" do
+
+    before do
+      @test_schema = SchemaGenerator.new { |g|
+        g.has_boolean key: :boolean
+      }.generate_schema
+    end
+
+    it "should validate booleans" do
+      candidate = { boolean: true}.to_json
+      @test_schema.validate(candidate: candidate).must_be :empty?
+    end
+
+    it "should return errors for non-booleans" do
+      candidate = { boolean: 1 }.to_json
+      @test_schema.validate(candidate: candidate).wont_be :empty?
+    end
+  end
+end

data/test/primitives_date_test.rb

@@ -0,0 +1,28 @@
+
+require 'test_helper'
+require 'json'
+
+# This test suite covers the basic concept of validating that a value is a
+# certain type
+
+module EasyJSONMatcher
+
+  describe "Date primitive" do
+
+    before do
+      @test_schema = SchemaGenerator.new { |g|
+        g.has_date key: :date
+      }.generate_schema
+    end
+
+    it "should validate dates" do
+      candidate = { date: "2015-04-01"}.to_json
+      @test_schema.validate(candidate: candidate).must_be :empty?
+    end
+
+    it "should return errors for non-dates" do
+      candidate = { date: "hello" }.to_json
+      @test_schema.validate(candidate: candidate).wont_be :empty?
+    end
+  end
+end

data/test/primitives_number_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+require 'json'
+
+# This test suite covers the basic concept of validating that a value is a
+# certain type
+
+module EasyJSONMatcher
+
+  describe "Number Validations" do
+
+    before do
+      @test_schema = SchemaGenerator.new { |g|
+        g.has_number key: :number
+      }.generate_schema
+    end
+
+    it "should validate Strings" do
+      candidate = { number: 1 }.to_json
+      @test_schema.validate(candidate: candidate).must_be :empty?
+    end
+
+    it "should return errors for non-strings" do
+      candidate = { number: "hello" }.to_json
+      @test_schema.validate(candidate: candidate).wont_be :empty?
+    end
+  end
+end

data/test/primitives_object_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+require 'json'
+
+# This test suite covers the basic concept of validating that a value is a
+# certain type
+
+module EasyJSONMatcher
+
+  describe "Object primitive test" do
+
+    before do
+      @test_schema = SchemaGenerator.new { |g|
+        g.has_object key: :object
+      }.generate_schema
+    end
+
+    it "should validate booleans" do
+      candidate = { object: { a: 1}}.to_json
+      @test_schema.validate(candidate: candidate).must_be :empty?
+    end
+
+    it "should return errors for non-booleans" do
+      candidate = { object: 1 }.to_json
+      @test_schema.validate(candidate: candidate).wont_be :empty?
+    end
+  end
+end

data/test/primitives_string_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+require 'json'
+
+# This test suite covers the basic concept of validating that a value is a
+# certain type
+
+module EasyJSONMatcher
+
+  describe "Basic Type Validations" do
+
+    before do
+      @test_schema = SchemaGenerator.new { |g|
+        g.has_string key: :string
+      }.generate_schema
+    end
+
+    it "should validate Strings" do
+      candidate = { string: "hello" }.to_json
+      @test_schema.validate(candidate: candidate).must_be :empty?
+    end
+
+    it "should return errors for non-strings" do
+      candidate = { string: 1 }.to_json
+      @test_schema.validate(candidate: candidate).wont_be :empty?
+    end
+  end
+end

data/test/primtives_value_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+require 'json'
+
+# This test suite covers the basic concept of validating that a value is a
+# certain type
+
+module EasyJSONMatcher
+
+  describe "Value primitive test" do
+
+    before do
+      @test_schema = SchemaGenerator.new { |g|
+        g.has_boolean key: :value
+      }.generate_schema
+    end
+
+    it "should validate any explicitly set value" do
+      candidate = { value: nil}.to_json
+      @test_schema.validate(candidate: candidate).must_be :empty?
+    end
+
+  end
+end

data/test/required_validation_test.rb

@@ -4,8 +4,8 @@ class RequireValidationTest < ActiveSupport::TestCase
 
   test "As a user I want to insist that a value is present" do
     astronaut_schema = EasyJSONMatcher::SchemaGenerator.new { |s|
-      s.has_attribute key: :has_oxygen, opts: {type: :boolean, required: true}
-      s.has_attribute key: :name, opts: {type: :string}
+      s.has_attribute key: :has_oxygen, opts: [:boolean, :required]
+      s.has_attribute key: :name, opts: [:string]
     }.generate_schema
 
     valid_astronaut = {
@@ -13,25 +13,25 @@ class RequireValidationTest < ActiveSupport::TestCase
       name: 'Buzz Aldrin'
     }.to_json
 
-    assert(astronaut_schema.valid?(valid_astronaut), "#{valid_astronaut} should be a valid object")
+    assert(astronaut_schema.valid?(candidate: valid_astronaut), "#{valid_astronaut} should be a valid object")
 
     invalid_astronaut = {
       name: 'Neil Armstrong'
     }.to_json
 
-    assert_not(astronaut_schema.valid?(invalid_astronaut), "#{invalid_astronaut} should not be a valid object")
+    assert_not(astronaut_schema.valid?(candidate: invalid_astronaut), "#{invalid_astronaut} should not be a valid object")
   end
 
   test "As a user I want validations to pass if the value is not present and I have not required it to be there" do
     astronaut_schema = EasyJSONMatcher::SchemaGenerator.new { |s|
-      s.has_attribute key: :has_oxygen, opts: {type: :boolean}
-      s.has_attribute key: :name, opts: {type: :string}
+      s.has_attribute key: :has_oxygen, opts: [:boolean]
+      s.has_attribute key: :name, opts: [:string]
     }.generate_schema
 
     valid_astronaut = {
       name: 'Buzz Aldrin'
     }.to_json
 
-    assert(astronaut_schema.valid?(valid_astronaut), "#{valid_astronaut} should be valid since :has_oxygen is not required")
+    assert(astronaut_schema.valid?(candidate: valid_astronaut), "#{valid_astronaut} should be valid since :has_oxygen is not required")
   end
 end

data/test/schema_generator_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+module EasyJSONMatcher
+  
+  describe SchemaGenerator do
+
+    describe "SchemaGenerator#generate_schema" do
+
+      it "should return a validator" do
+      end
+    end
+
+    describe "Global Options" do
+
+      it "should accept a global options parameter" do
+      end
+
+      it "should filter out Schema options before passing them onto the NodeGenerator" do
+      end
+    end
+  end
+end
+

data/test/strict_mode_test.rb

@@ -1,63 +1,34 @@
 require 'test_helper'
 
-class StrictModeTest < ActiveSupport::TestCase
-
-  test "As a user I want my schema to only validate objects iff the set of keys
-        in the candidate minus the set of keys specified in the schema equals the
-        empty set" do
-
-    test_schema = EasyJSONMatcher::SchemaGenerator.new(global_opts: {strict: true}) {|s|
-      s.has_string key: :first
-      s.has_string key: :second
-      s.has_string key: :third
-    }.generate_schema
-
-    too_many_planets = {
-      first:  'Zeus',
-      second: 'Poseidon',
-      third:  'Hera',
-      fourth: 'Demeter'
-    }.to_json
-
-    assert_not(test_schema.valid?(too_many_planets), "#{too_many_planets} should not be valid as it has the unspecified :fourth key")
-  end
+module EasyJSONMatcher
 
-  setup do
-    @test_schema = EasyJSONMatcher::SchemaGenerator.new(global_opts: {strict: true}) {|s|
-      s.has_string key: :name
-      s.contains_node key: :about do |n|
-        n.has_string  key: :religion
-        n.has_string  key: :domain
-      end
-    }.generate_schema
-  end
+  describe "Strict Mode" do
 
-  test "As a user, if I have specified strict at the top level, I expect it to apply to nested nodes" do
+    subject {
+      SchemaGenerator.new(global_opts: [ :strict ]) { |s|
+        s.has_attribute key: :a, opts: []
+        s.has_attribute key: :b, opts: []
+      }.generate_schema
+    }
 
-    poseidon = {
-      name: 'Poseidon',
-      about: {
-        religion: 'Olympian Gods',
-        domain: 'The Sea',
-        hobbies: ['Battleships Champion', 'Horse Tamer', 'Seismology']
-      }
-    }.to_json
 
-    assert_not(@test_schema.valid?(poseidon), "#{poseidon} should not be valid as hobbies wasn't expected in the schema, and he didn't have any")
-  end
+    it "should validate candidates with the correct keys" do
+      candidate = {
+        a: "a",
+        b: "b"
+      }.to_json
+
+      subject.validate(candidate: candidate).must_be :empty?
+    end
+
+    it "should not validate candidates with extra keys" do
+      candidate = {
+        a: "a",
+        b: "b",
+        c: "c"
+      }.to_json
 
-  test "As a user, if the strict validation fails, I want to be told why" do
-    zeus = {
-      name: 'Zeus',
-      about: {
-        religion: 'Olympian Gods',
-        domain: 'Firmament',
-        spouse: 'Hera',
-        address: 'Mount Olympus'
-      }
-    }.to_json
-
-    assert_not(@test_schema.valid? zeus)
-    assert_match(/\[:spouse, :address\] found in addition to expected keys/, @test_schema.get_errors[:about][:node_errors_][0])
+      subject.validate(candidate: candidate).wont_be :empty?
+    end
   end
 end

data/test/test_helper.rb

@@ -1,9 +1,11 @@
-require 'pretty_backtrace/enable'
-require 'minitest'
-require 'minitest/autorun'
-require 'active_support'
-require 'mocha/mini_test'
-require 'easy_json_matcher'
+require "pretty_backtrace/enable"
+require "minitest"
+require "minitest/autorun"
+require "active_support"
+require "mocha/mini_test"
+require "easy_json_matcher"
+require "pp"
+require "byebug"
 
 # Filter out Minitest backtrace while allowing backtrace from other libraries
 # to be shown.

data/test/validating_arrays_test.rb

@@ -1,139 +1,47 @@
 require 'test_helper'
-
-class ValidatingArraysTest < ActiveSupport::TestCase
-
-  test "As a user I want to validate that my arrays can contain objects of a specific schema" do
-    EasyJSONMatcher::SchemaGenerator.new {|s|
-
-      s.has_attribute key: :name, opts: {type: :string, required: true}
-      s.has_attribute key: :spouse, opts: {type: :string}
-    }.register as: :greek_hero
-
-    test_schema = EasyJSONMatcher::SchemaGenerator.new {|s|
-      s.contains_array(key: :data, opts: {required: true}) do |a|
-        a.should_only_contain(type: :schema, opts: {name: :greek_hero})
-      end
-    }.generate_schema
-
-    valid_json = {
-      data: [{
+require "easy_json_matcher/array_validator"
+
+module EasyJSONMatcher
+
+  describe ArrayValidator do
+
+    before do
+      SchemaGenerator.new {|s|
+        s.has_attribute key: :name, opts: [:string, :required]
+        s.has_attribute key: :spouse, opts: [:string, :required]
+      }.register as: :greek_hero
+    end 
+
+    subject{
+      test_schema = SchemaGenerator.new {|s|
+        s.contains_array(key: :data) do |a|
+          a.elements_should be: [:greek_hero]
+        end
+      }.generate_schema
+    }
+
+    it "should validate each value in the array" do
+      validator = SchemaGenerator.new { |s|
+        s.contains_array(key: :array) do |a|
+          a.elements_should be: [:number]
+        end
+      }.generate_schema
+      candidate = { array: [1,2,3,4,"oops"] }.to_json
+      validator.validate(candidate: candidate).wont_be :empty?
+    end
+
+    it "should validate schemas" do
+      invalid_json = {
+        data: [{
           name: 'More Greek Heroes',
           items: ['Hector', 'Ajax', 'Hippolyta', 'Penthesila']
         },
-      {
-        name: 'Roman Heroes',
-        items: ['Romulus', 'Remus', 'Aeneus']
+        {
+          name: 'Roman Heroes',
+          items: ['Romulus', 'Remus', 'Aeneus']
         }]
-    }.to_json
-
-    assert(test_schema.valid?(valid_json), "#{valid_json} should have been validated as it follows the correct schema")
-
-    invalid_json = {
-      data: [1,2,3,4,5]
-    }.to_json
-
-    assert_not(test_schema.valid?(invalid_json), "#{invalid_json} should not have validated as it does not contain a :heroes schema")
-  end
-
-  test "As a user I want to validate that my arrays only contain strings" do
-    test_schema = EasyJSONMatcher::SchemaGenerator.new {|s|
-      s.has_string key: :name, opts: {required: true}
-      s.contains_array key: :data, opts: {required: true} do |a|
-        a.should_only_contain_strings
-      end
-    }.generate_schema
-
-    valid_json = {
-      name: 'German Heroes',
-      data: ['Brunhilda', 'Siegfried', 'Faust']
-    }.to_json
-
-    assert(test_schema.valid?(valid_json), "#{valid_json} should have been valid as it only contained strings")
-
-    invalid_json = {
-      name: 'Fibonacci sequence',
-      data: [0,1,1,2,3,5,8,13,24]
-    }.to_json
-
-    assert_not(test_schema.valid?(invalid_json), "#{invalid_json} should not have been valid as it did not contain strings")
-
-  end
-
-  test 'As a user I want to validate that my arrays only contain numbers' do
-    test_schema = EasyJSONMatcher::SchemaGenerator.new {|s|
-      s.has_string key: :name, opts: {required: true}
-      s.contains_array key: :data, opts: {required: true} do |a|
-        a.should_only_contain_numbers
-      end
-    }.generate_schema
-
-    valid_json = {
-      name: 'Square Numbers',
-      data: [1,4,9,16,25,36,49,64]
-    }.to_json
-
-    assert(test_schema.valid?(valid_json), "#{valid_json} should have been valid as it contained only numbers")
-
-    invalid_json = {
-      name: 'Notable Scots',
-      data: ['Alexander Fleming', 'Adam Smith', 'John Logie Baird', 'St. Andrew', 'St. Columba', 1, 2, 3, 4, 5]
-    }.to_json
-    assert_not(test_schema.valid?(invalid_json), "#{invalid_json} should not have been valid as it did not only contain numbers")
-  end
-
-  test 'As a user I want to validate that my arrays only contain booleans' do
-
-    test_schema = EasyJSONMatcher::SchemaGenerator.new {|s|
-      s.has_string key: :name, opts: {required: true}
-      s.contains_array key: :data, opts: {required: true} do |a|
-        a.should_only_contain_booleans
-      end
-    }.generate_schema
-
-    valid_json = {
-      name: 'Predicates',
-      data: [true, true, false, true, false, false]
-    }.to_json
-
-    assert(test_schema.valid?(valid_json), "#{valid_json} should have been valid as it contains only booleans")
-
-    invalid_json = {
-      name: 'Notable English',
-      data: ['St. George', 'Winston Churchill', 'Admiral Nelson', true, true, false, false]
-    }.to_json
-
-    assert_not(test_schema.valid?(invalid_json), "#{invalid_json} should have been invalid as it contains strings")
-  end
-
-  test 'As a user I want to validate that my arrays contain only objects' do
-
-    test_schema = EasyJSONMatcher::SchemaGenerator.new { |s|
-      s.has_string key: :name, opts: {required: true}
-      s.contains_array key: :data, opts: {required: true} do |a|
-        a.should_only_contain_objects
-      end
-    }.generate_schema
-
-    valid_json = {
-      name: 'Hand of Cards',
-      data: [
-        {suite: 'Spades', value: 'Ace'},
-        {suite: 'Hearts', value: 'Queen'},
-        {suite: 'Clubs', value: 'Jack'},
-        {suite: 'Diamonds', value: '3'}]
-    }.to_json
-
-    assert(test_schema.valid?(valid_json), "#{valid_json} should have been valid as it only contains objects")
-
-    invalid_json = {
-      name: 'Norse Gods',
-      data: [{'Thor': 'Thunder'}, 'Odin', 'Loki', 'Freya']
-    }.to_json
-
-    assert_not(test_schema.valid?(invalid_json), "#{invalid_json} should not have been valid as it does not only contain objects")
-  end
-
-  test 'as a user I want to validate that my arrays contain only dates' do
-
+      }.to_json
+      subject.validate(candidate: invalid_json).wont_be :empty?
+    end
   end
 end

data/test/validation_chain_factory_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+require "easy_json_matcher/validation_chain_factory"
+require "easy_json_matcher/unknown_validation_step_error"
+
+module EasyJSONMatcher
+
+  describe ValidationChainFactory do
+
+    STD_TYPES = [:object, :string, :number, :date, :boolean, :value, :required, :not_required]
+
+    describe "#get_step_for" do
+
+      it "should return a validation step for all available value types" do
+        STD_TYPES.each do |type|
+          ValidationChainFactory.get_step_for(validating: type).wont_be :==, nil
+        end
+      end
+
+      it "should return a custom validator if :validating responds to call" do
+        can_be_called = ->(value, errors) { }
+        ValidationChainFactory.get_step_for(validating: can_be_called).
+          wont_be :==, nil
+      end
+
+      it "should otherwise raise an error" do
+        cannot_use = String.new
+        -> { ValidationChainFactory.get_step_for(validating: cannot_use) }.
+          must_raise UnknownValidationStepError
+      end
+    end
+
+    describe "#get_chain" do
+
+      it "should move :required validation to the start of the chain" do
+        chain = ValidationChainFactory.get_chain(steps: [:string, :required])
+        chain.check(value: nil)[0].must_match /no value found/
+      end
+
+      it "should put :not_required at the start if :required is not specified" do
+        chain = ValidationChainFactory.get_chain(steps: [:string])
+        chain.check(value: nil).must_be :empty?
+      end
+    end
+  end
+end

data/test/validation_chain_test_helper.rb

@@ -0,0 +1,13 @@
+require "easy_json_matcher/validation_chain_factory"
+
+module ValidationChainTestHelper
+
+  def get_instance(type:)
+    EasyJSONMatcher::ValidationChainFactory.get_step_for validating: type
+  end
+
+  def assert_chain_verifies(type:, test_value:, outcome:)
+    v_step = get_instance(type: type)
+    expect(v_step.check(value: test_value).empty?).must_be :==, outcome
+  end
+end

data/test/validation_step_array_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+require "easy_json_matcher/array_validator"
+
+module EasyJSONMatcher
+
+  describe ArrayValidator do
+
+    before do
+      @subject = ArrayValidator.new verify_content_as: [:string]
+    end
+
+    describe "Validating Array Types" do
+
+      it "should return valid for empty arrays" do
+        @subject.check(value: []).must_be :empty?
+      end
+
+      it "should return errors for any other object" do
+        @subject.check(value: 1).wont_be :empty?
+      end
+
+      it "should check all the content is of a particular type" do
+        @subject.check(value: [1,2,3]).wont_be :empty?
+      end
+    end
+  end
+end

data/test/validation_step_boolean_test.rb

@@ -0,0 +1,19 @@
+require "test_helper"
+require "validation_chain_test_helper"
+
+include ValidationChainTestHelper
+
+describe "Boolean Validation Step" do
+
+  describe "should be able to return an instance that validates booleans" do
+
+    it "should not return any errors for a boolean" do
+      [true,false].each { |b| assert_chain_verifies(type: :boolean, test_value: b, outcome: true)}
+    end
+
+    it "should return an error for an invalid boolean" do
+      no_bool = 0
+      assert_chain_verifies(type: :boolean, test_value: no_bool, outcome: false)
+    end
+  end
+end

data/test/validation_step_date_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+require "validation_chain_test_helper"
+
+include ValidationChainTestHelper
+
+describe "Date Validation Step" do
+
+  describe "should be able to return a instance that validates dates" do
+
+    it "should not return any errors for a valid ISO8601 date" do
+      date = "2020-03-01"
+      assert_chain_verifies(type: :date, test_value: date, outcome: true)
+    end
+
+    it "should return an error for an invalid date" do
+      no_date = 1
+      assert_chain_verifies(type: :date, test_value: no_date, outcome: false)
+    end
+  end
+end