easy_json_matcher 0.0.2.pre.1 → 0.1.0

data/test/easy_json_matcher_test.rb

@@ -1,8 +1,9 @@
 require 'test_helper'
 require 'json'
 
-
-class JsonapiMatcherTest < ActiveSupport::TestCase
+# 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
@@ -11,7 +12,7 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
       schema.contains_node(key: :data) do |node|
         node.has_attribute(key: :title, opts: {type: :string})
       end
-    }.register(schema_name: :test)
+    }.register(as: :test)
 
     valid_json = {
                    data: {
@@ -21,12 +22,46 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
     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_attribute(key: :number, opts: {type: :number, required: :true})
-    }.generate_node
+      schema.has_number(key: :number, opts: {required: :true})
+    }.generate_schema
 
     valid_json = {
       number: 5.55,
@@ -48,9 +83,9 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
   test "As a user I want to be able to validate booleans" do
 
     test_schema = EasyJSONMatcher::SchemaGenerator.new {|schema|
-      schema.has_attribute(key: :true, opts: {type: :boolean})
-      schema.has_attribute(key: :false, opts: {type: :boolean})
-    }.generate_node
+      schema.has_boolean(key: :true)
+      schema.has_boolean(key: :false)
+    }.generate_schema
 
     valid_json = {
       true: true,
@@ -71,7 +106,7 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
   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_node
+    }.generate_schema
 
     valid_json = {
       array: []
@@ -88,8 +123,8 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
 
   test "As a user I want to be able to validate date values" do
     test_schema = EasyJSONMatcher::SchemaGenerator.new { |schema|
-      schema.has_attribute(key: :date, opts: {type: :date})
-    }.generate_node
+      schema.has_date(key: :date)
+    }.generate_schema
 
     valid_json = {
       date: "2015-01-15"
@@ -111,8 +146,8 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
 
   test "As a user I want to validate object values" do
     test_schema = EasyJSONMatcher::SchemaGenerator.new { |schema|
-      schema.has_attribute(key: :object, opts: {type: :object})
-    }.generate_node
+      schema.has_object(key: :object)
+    }.generate_schema
 
     is_an_object = {}
 
@@ -133,24 +168,21 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
 
   # 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.
-  # However, if in future we want to implement the :required option then in the
-  # case of ValueValidator we will be stuck because for all of the other Validator
-  # classes nil indicates a missing value, but in the case of the ValueValidator
-  # we just want to check that there is a key available. It makes sense, therefore,
-  # to reverse the dependency such that the Node instance is passed to the Validator
-  # with its key and it then tests for the presence of the attribute and what it
-  # whether or not it is available
+  # 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_attribute(key: :array,    opts: {type: :value})
-        schema.has_attribute(key: :boolean,  opts: {type: :value})
-        schema.has_attribute(key: :date, opts: {type: :value})
-        schema.has_attribute(key: :number, opts: {type: :value})
-        schema.has_attribute(key: :object, opts: {type: :value})
-        schema.has_attribute(key: :string, opts: {type: :value})
-        schema.has_attribute(key: :null, opts: {type: :value})
-      }.generate_node
+        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 = {
@@ -179,7 +211,7 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
           n3.has_attribute(key: :level_3_attribute, opts: {type: :number})
         end
       end
-    }.generate_node
+    }.generate_schema
 
     valid_json = {
       level_1_attribute: 1,
@@ -194,30 +226,37 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
     assert(test_schema.valid?(valid_json), "Nested JSON was not correctly validated")
   end
 
-  test "As a user I want to know why my json was not valid" do
-
-    class Validator
-      def valid?(json)
-        raise EasyJSONMatcher::ValidationError.new ("Oops!!")
-      end
-    end
-
-    test_schema = EasyJSONMatcher::SchemaGenerator.new { |schema|
-      schema.has_attribute(key: :oops, opts: {type: :value})
-      schema.contains_node(key: :nested_oops) do |node|
-        node.has_attribute(key: :bigger_oops, opts: {type: :value})
+  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_node
+    }.generate_schema
 
-    # This JSON only reflects the structure of the above, it's validity is rendered
-    # irrelevant by our monkey-patch of Validator
     valid_json = {
-      oops: 'oops',
-      nested_oops: {
-        bigger_oops: 'bigger_oops'
+      fish_name: 'Clownfish',
+      scientific_name: {
+        genus: 'Amphiprion',
+        species: 'ocellaris'
       }
-    }
-    flunk "Implement me"
+    }.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/error_messages_test.rb

@@ -0,0 +1,148 @@
+require 'test_helper'
+
+class ErrorMessagesTest < ActiveSupport::TestCase
+
+  test "As a user I want to know why my json was not valid" do
+
+    test_schema = EasyJSONMatcher::SchemaGenerator.new { |schema|
+      schema.has_string key: :oops
+      schema.has_value key: :ok
+      schema.contains_node(key: :nested_oops) do |node|
+        node.has_value key: :ok
+        node.has_string key: :bigger_oops
+      end
+    }.generate_schema
+
+    has_errors = {
+      oops: 1,
+      ok: 'ok',
+      nested_oops: {
+        ok: 'ok',
+        bigger_oops: 2
+      }
+    }.to_json
+
+    # The resulting error object should show an error for oops, and an error in the
+    # :nested_oops object for :bigger_oops. It should not show any errors for either
+    # of the :oks.
+
+    # Generate error messages. Better test that the thing is definitely invalid too...
+    assert_not(test_schema.valid? has_errors)
+
+    assert_match(/.*is not a String/, test_schema.get_errors[:oops][0])
+    assert_match( /.*is not a String/, test_schema.get_errors[:nested_oops][:bigger_oops][0])
+  end
+
+  test "As a user, given that I have specified that an array should be mapped to a key and that the actual value
+        is not an array, I want to know that the value is not an array" do
+
+    test_schema = EasyJSONMatcher::SchemaGenerator.new do |s|
+      s.contains_array(key: :arr)
+    end.generate_schema
+
+    wrong_type = {
+      arr: "This not an array"
+    }.to_json
+
+    #As above just check that the validator is actually behaving itself
+    assert_not(test_schema.valid? wrong_type)
+
+    assert_match(/.*is not an Array/, test_schema.get_errors[:arr][0])
+  end
+
+  test "As a user, given that I have specified that an array should contain a specific
+        type of value and the array contains other types of value, I want to know which
+        value was the wrong type and why" do
+
+        test_schema = EasyJSONMatcher::SchemaGenerator.new {|s|
+          s.contains_array key: :array do |a|
+            a.should_only_contain type: :string
+          end
+        }.generate_schema
+
+        episodes_where_sheldon_says_bazinga_in_series_2 = {
+          array: [1,2,3]
+        }.to_json
+
+        assert_not(test_schema.valid? episodes_where_sheldon_says_bazinga_in_series_2)
+        assert_match(/.* is not a String/, test_schema.get_errors[:array][0][0])
+  end
+
+  test "As a user, given that I have specified that a boolean should map to a given
+        key and that the actual value is not a boolean, I want to now that the
+        value is not a boolean" do
+
+    test_schema = EasyJSONMatcher::SchemaGenerator.new { |s|
+      s.has_boolean(key: :bool)
+    }.generate_schema
+
+    no_bool = {
+      bool: "false"
+    }.to_json
+
+    assert_not(test_schema.valid? no_bool)
+
+    assert_match(/.* is not a Boolean/, test_schema.get_errors[:bool][0])
+  end
+
+  test "As a user, given that I have specified that a date should map to a given key
+        and that the actual value is not a date, I want to be informed that the value
+        is not a date" do
+
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|s|
+      s.has_date(key: :date)
+    }.generate_schema
+
+     no_date = {
+       date: "hello world"
+     }.to_json
+
+     assert_not(test_schema.valid? no_date)
+
+     assert_match(/.* is not a Date/, test_schema.get_errors[:date][0])
+  end
+
+  test "As a user, given that I have specified that a value should be a number,
+        I want to be informed that the value was not a number" do
+
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|s|
+      s.has_number(key: :number)
+    }.generate_schema
+
+    no_number = {
+      number: 'six'
+    }.to_json
+
+
+    assert_not(test_schema.valid? no_number)
+    assert_match(/.* is not a Number/, test_schema.get_errors[:number][0])
+  end
+
+  test "As a user, given that I have specified that a value should be an object,
+  I want an error message to inform me if a value is not an object" do
+
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|s|
+      s.has_object(key: :object)
+    }.generate_schema
+
+    no_object = {
+      object: false
+    }.to_json
+
+    assert_not(test_schema.valid? no_object)
+    assert_match(/.* is not an Object/, test_schema.get_errors[:object][0])
+  end
+
+  test "As a user, given that I have supplied an invalid JSON object, I want an
+  error message to inform me that the candidate could not be parsed" do
+
+    test_schema = EasyJSONMatcher::SchemaGenerator.new {|s|
+      s.has_object(key: :object)
+    }.generate_schema
+
+    not_json = 'this is not a JSON String'
+
+    test_schema.valid? not_json
+    assert_match(/.* is not a valid JSON String/, test_schema.get_errors[:root][0])
+  end
+end

data/test/global_validation_options_test.rb

@@ -0,0 +1,48 @@
+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?)
+  end
+end

data/test/managing_schemas_test.rb

@@ -6,7 +6,7 @@ class ManagingSchemasTest < ActiveSupport::TestCase
     @name = :test
     EasyJSONMatcher::SchemaGenerator.new { |schema|
       schema.has_attribute(key: :name, opts: {type: :string, required: true})
-    }.register(schema_name: @name)
+    }.register(as: @name)
   end
 
   test "As a user I want to be able to register a Schema so I can reuse it later" do
@@ -18,27 +18,27 @@ class ManagingSchemasTest < ActiveSupport::TestCase
       name: 'Green Mandarin'
     }.to_json
 
-    schema = EasyJSONMatcher::SchemaLibrary.get_schema(@name)
+    schema = EasyJSONMatcher::SchemaLibrary.get_schema(name: @name)
     assert(schema.valid?(test_schema), "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.to_s}-wibble")
+      EasyJSONMatcher::SchemaLibrary.get_schema(name: "#{@name.to_s}-wibble")
     end
   end
 
   test "As a user I want to reuse a schema within another schema" do
     test_schema = EasyJSONMatcher::SchemaGenerator.new { |s|
-      s.has_attribute(key: :is_present, opts: {type: :boolean, required: true})
-      s.contains_schema(schema_name: @name)
-    }.generate_node
+      s.has_boolean(key: :is_present, opts: {required: true})
+      s.has_schema(key: @name, opts: {name: @name, required: true})
+    }.generate_schema
 
     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'})
@@ -54,15 +54,15 @@ class ManagingSchemasTest < ActiveSupport::TestCase
         atts.has_attribute key: :alpha_3,  opts: {type: :string, required: true}
         atts.has_attribute key: :name,     opts: {type: :string, required: true}
       end
-    }.register(schema_name: :country)
+    }.register(as: :country)
 
     EasyJSONMatcher::SchemaGenerator.new {|country_payload|
-      country_payload.contains_schema(schema_name: :country, opts: {key: :data})
-    }.register(schema_name: :country_payload)
+      country_payload.has_attribute(key: :data, opts: {name: :country, type: :schema})
+    }.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\"}}}"
 
-    validator = EasyJSONMatcher::SchemaLibrary.get_schema(:country_payload)
+    validator = EasyJSONMatcher::SchemaLibrary.get_schema(name: :country_payload)
     assert(validator.valid? valid_json)
   end
 end