easy_json_matcher 0.0.1 → 0.0.2.pre.1

data/test/{jsonapi_matcher_test.rb → easy_json_matcher_test.rb}

@@ -14,10 +14,10 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
     }.register(schema_name: :test)
 
     valid_json = {
-                     data: {
-                          'title'=> "Here's a title"
-                          }
-                    }.to_json
+                   data: {
+                        'title'=> "here's a title"
+                        }
+                  }.to_json
     assert(test_schema.valid? valid_json)
   end
 
@@ -25,7 +25,7 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
   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})
+      schema.has_attribute(key: :number, opts: {type: :number, required: :true})
     }.generate_node
 
     valid_json = {
@@ -38,6 +38,11 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
       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
@@ -57,8 +62,9 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
     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
 
@@ -80,10 +86,6 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
     assert(!test_schema.valid?(invalid_json), "\"1\" is not a valid array value")
   end
 
-  test "As a user I want to be able to specify what should be found in an array" do
-    flunk "Implement me"
-  end
-
   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})
@@ -124,7 +126,7 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
 
     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
@@ -192,16 +194,6 @@ class JsonapiMatcherTest < ActiveSupport::TestCase
     assert(test_schema.valid?(valid_json), "Nested JSON was not correctly validated")
   end
 
-  test "As a user I want to be able to register a Schema so I can reuse it later" do
-
-    EasyJSONMatcher::SchemaGenerator.new { |schema|
-      schema.has_attribute(key: :ignore_me, opts: {type: :value})
-    }.register(schema_name: :test)
-
-    assert(EasyJSONMatcher.available_schemas.include?(:test), ":test not found in available_nodes")
-  end
-
-
   test "As a user I want to know why my json was not valid" do
 
     class Validator

data/test/managing_schemas_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+class ManagingSchemasTest < ActiveSupport::TestCase
+
+  setup do
+    @name = :test
+    EasyJSONMatcher::SchemaGenerator.new { |schema|
+      schema.has_attribute(key: :name, opts: {type: :string, required: true})
+    }.register(schema_name: @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
+
+  test "As as user I want to reuse a saved schema"  do
+    test_schema = {
+      name: 'Green Mandarin'
+    }.to_json
+
+    schema = EasyJSONMatcher::SchemaLibrary.get_schema(@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")
+    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
+
+    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")
+
+    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
+
+  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(schema_name: :country)
+
+    EasyJSONMatcher::SchemaGenerator.new {|country_payload|
+      country_payload.contains_schema(schema_name: :country, opts: {key: :data})
+    }.register(schema_name: :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)
+    assert(validator.valid? valid_json)
+  end
+end

data/test/required_validation_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+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}
+    }.generate_node
+
+    valid_astronaut = {
+      has_oxygen: true,
+      name: 'Buzz Aldrin'
+    }.to_json
+
+    assert(astronaut_schema.valid?(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")
+  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}
+    }.generate_node
+
+    valid_astronaut = {
+      name: 'Buzz Aldrin'
+    }.to_json
+
+    assert(astronaut_schema.valid?(valid_astronaut), "#{valid_astronaut} should be valid since :has_oxygen is not required")
+  end
+end

data/test/validating_arrays_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+class ValidatingArraysTest < ActiveSupport::TestCase
+
+  setup do
+    @test_schema = EasyJSONMatcher::SchemaGenerator.new { |s|
+      s.has_attribute(key: :name, opts: {type: :string})
+      s.contains_array(key: :items, opts: {required: true}) do |array|
+        array.should_only_contain(type: :string, opts: {required: true})
+      end
+    }.generate_node
+  end
+
+  test "As a user I want to validate that my arrays contain values of the correct type" do
+    valid_json = {
+      name: 'Greek Heroes',
+      items: ['Heracles', 'Perseus', 'Theseus', 'Achilles']
+    }.to_json
+
+    assert(@test_schema.valid?(valid_json), "#{valid_json} should have been valid")
+
+    invalid_no_items = {
+      name: 'Strictly Come Dancing Heroes'
+    }.to_json
+
+    assert_not(@test_schema.valid?(invalid_no_items), "#{invalid_no_items} should not have been valid as it has no array called items")
+
+    invalid_wrong_items = {
+      name: 'Prime Heroes',
+      items: [1,3,5,7,9,8191]
+    }.to_json
+
+    assert_not(@test_schema.valid?(invalid_wrong_items), "#{invalid_wrong_items} should not have been validated since the array contains the wrong type")
+  end
+
+  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(schema_name: :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_node
+
+    valid_json = {
+      data: [{
+          name: 'Greek Heroes',
+          items: ['Hector', 'Ajax', 'Hippolyta', 'Penthesila']
+        },
+      {
+        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]
+    }
+
+    assert_not(test_schema.valid?(invalid_json), "#{invalid_json} should not have validated as it does not contain a :heroes schema")
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_json_matcher
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2.pre.1
 platform: ruby
 authors:
 - WJD Hamilton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-10 00:00:00.000000000 Z
+date: 2016-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -52,10 +52,12 @@ files:
 - lib/easy_json_matcher/boolean_validator.rb
 - lib/easy_json_matcher/content_wrapper.rb
 - lib/easy_json_matcher/date_validator.rb
+- lib/easy_json_matcher/exceptions.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_library.rb
 - lib/easy_json_matcher/string_validator.rb
 - lib/easy_json_matcher/validation_error.rb
 - lib/easy_json_matcher/validator.rb
@@ -63,7 +65,6 @@ files:
 - lib/easy_json_matcher/value_validator.rb
 - lib/easy_json_matcher/version.rb
 - lib/tasks/jsonapi_matcher_tasks.rake
-- test/date_format_test.rb
 - test/dummy/README.rdoc
 - test/dummy/Rakefile
 - test/dummy/app/assets/javascripts/application.js
@@ -100,9 +101,12 @@ files:
 - test/dummy/public/422.html
 - test/dummy/public/500.html
 - test/dummy/public/favicon.ico
+- test/easy_json_matcher_test.rb
 - test/json_api_home.txt
-- test/jsonapi_matcher_test.rb
+- test/managing_schemas_test.rb
+- test/required_validation_test.rb
 - test/test_helper.rb
+- test/validating_arrays_test.rb
 homepage: https://github.com/wjdhamilton/easy-json-matcher
 licenses:
 - MIT
@@ -118,9 +122,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2
@@ -128,10 +132,12 @@ signing_key:
 specification_version: 4
 summary: Easily test your JSON output with templates and Schemas
 test_files:
-- test/date_format_test.rb
+- test/required_validation_test.rb
+- test/validating_arrays_test.rb
+- test/easy_json_matcher_test.rb
 - test/json_api_home.txt
+- test/managing_schemas_test.rb
 - test/test_helper.rb
-- test/jsonapi_matcher_test.rb
 - test/dummy/config.ru
 - test/dummy/bin/rails
 - test/dummy/bin/bundle