dato_json_schema 0.20.8

data/test/data_scaffold.rb

@@ -0,0 +1,241 @@
+module DataScaffold
+  def self.data_sample
+    {
+      "name" => "cloudnasium"
+    }
+  end
+
+  def self.schema_sample
+    {
+      "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+      "title" => "Example API",
+      "description" => "An example API.",
+      "type" => [
+        "object"
+      ],
+      "definitions" => {
+        "app" => {
+          "$schema" => "http://json-schema.org/draft-04/hyper-schema",
+          "title" => "App",
+          "description" => "An app.",
+          "id" => "schemata/app",
+          "type" => [
+            "object"
+          ],
+          "definitions" => {
+            "config_vars" => {
+              "patternProperties" => {
+                "^\\w+$" => {
+                  "type" => ["null", "string"]
+                }
+              }
+            },
+            "contrived" => {
+              "allOf" => [
+                { "maxLength" => 30 },
+                { "minLength" => 3 }
+              ],
+              "anyOf" => [
+                { "minLength" => 3 },
+                { "minLength" => 5 }
+              ],
+              "oneOf" => [
+                { "pattern" => "^(foo|aaa)$" },
+                { "pattern" => "^(foo|zzz)$" }
+              ],
+              "not" => { "pattern" => "^$" }
+            },
+            "contrived_plus" => {
+              "allOf" => [
+                { "$ref" => "/schemata/app#/definitions/contrived/allOf/0" },
+                { "$ref" => "/schemata/app#/definitions/contrived/allOf/1" }
+              ],
+              "anyOf" => [
+                { "$ref" => "/schemata/app#/definitions/contrived/anyOf/0" },
+                { "$ref" => "/schemata/app#/definitions/contrived/anyOf/1" }
+              ],
+              "oneOf" => [
+                { "$ref" => "/schemata/app#/definitions/contrived/oneOf/0" },
+                { "$ref" => "/schemata/app#/definitions/contrived/oneOf/1" }
+              ],
+              "not" => {
+                "$ref" => "/schemata/app#/definitions/contrived/not"
+              }
+            },
+            "cost" => {
+              "description" => "running price of an app",
+              "example" => 35.01,
+              "maximum" => 1000.00,
+              "exclusiveMaximum" => true,
+              "minimum" => 0.0,
+              "exclusiveMinimum" => false,
+              "multipleOf" => 0.01,
+              "readOnly" => false,
+              "type" => ["number"],
+            },
+            "flags" => {
+              "description" => "flags for an app",
+              "example" => ["websockets"],
+              "items" => {
+                "pattern" => "^[a-z][a-z\\-]*[a-z]$"
+              },
+              "maxItems" => 10,
+              "minItems" => 1,
+              "readOnly" => false,
+              "type" => ["array"],
+              "uniqueItems" => true
+            },
+            "id" => {
+              "description" => "integer identifier of an app",
+              "example" => 1,
+              "maximum" => 10000,
+              "exclusiveMaximum" => false,
+              "minimum" => 0,
+              "exclusiveMinimum" => true,
+              "multipleOf" => 1,
+              "readOnly" => true,
+              "type" => ["integer"],
+            },
+            "identity" => {
+              "anyOf" => [
+                { "$ref" => "/schemata/app#/definitions/id" },
+                { "$ref" => "/schemata/app#/definitions/name" },
+              ]
+            },
+            "name" => {
+              "default" => "hello-world",
+              "description" => "unique name of app",
+              "example" => "name",
+              "maxLength" => 30,
+              "minLength" => 3,
+              "pattern" => "^[a-z][a-z0-9-]{3,30}$",
+              "readOnly" => false,
+              "type" => ["string"]
+            },
+            "owner" => {
+              "description" => "owner of the app",
+              "format" => "email",
+              "example" => "dwarf@example.com",
+              "readOnly" => false,
+              "type" => ["string"]
+            },
+            "production" => {
+              "description" => "whether this is a production app",
+              "example" => false,
+              "readOnly" => false,
+              "type" => ["boolean"]
+            },
+            "role" => {
+              "description" => "name of a role on an app",
+              "example" => "collaborator",
+              "readOnly" => true,
+              "type" => ["string"],
+            },
+            "roles" => {
+              "additionalProperties" => true,
+              "patternProperties" => {
+                "^\\w+$" => {
+                  "$ref" => "/schemata/app#/definitions/role"
+                }
+              }
+            },
+            "ssl" => {
+              "description" => "whether this app has SSL termination",
+              "example" => false,
+              "readOnly" => false,
+              "type" => ["boolean"]
+            },
+            "visibility" => {
+              "description" => "the visibility of hte app",
+              "enum" => ["private", "public"],
+              "example" => false,
+              "readOnly" => false,
+              "type" => ["string"]
+            },
+          },
+          "properties" => {
+            "config_vars" => {
+              "$ref" => "/schemata/app#/definitions/config_vars"
+            },
+            "contrived" => {
+              "$ref" => "/schemata/app#/definitions/contrived"
+            },
+            "cost" => {
+              "$ref" => "/schemata/app#/definitions/cost"
+            },
+            "flags" => {
+              "$ref" => "/schemata/app#/definitions/flags"
+            },
+            "id" => {
+              "$ref" => "/schemata/app#/definitions/id"
+            },
+            "name" => {
+              "$ref" => "/schemata/app#/definitions/name"
+            },
+            "owner" => {
+              "$ref" => "/schemata/app#/definitions/owner"
+            },
+            "production" => {
+              "$ref" => "/schemata/app#/definitions/production"
+            },
+            "ssl" => {
+              "$ref" => "/schemata/app#/definitions/ssl"
+            },
+            "visibility" => {
+              "$ref" => "/schemata/app#/definitions/visibility"
+            }
+          },
+          "additionalProperties" => false,
+          "dependencies" => {
+            "production" => "ssl",
+            "ssl" => {
+              "properties" => {
+                "cost" => {
+                  "minimum" => 20.0,
+                },
+                "name" => {
+                  "$ref" => "/schemata/app#/definitions/name"
+                },
+              }
+            }
+          },
+          "maxProperties" => 10,
+          "minProperties" => 1,
+          "required" => ["name"],
+          "links" => [
+            "description" => "Create a new app.",
+            "href" => "/apps",
+            "method" => "POST",
+            "rel" => "create",
+            "schema" => {
+              "properties" => {
+                "name" => {
+                  "$ref" => "#/definitions/app/definitions/name"
+                },
+              }
+            },
+            "targetSchema" => {
+              "$ref" => "#/definitions/app"
+            }
+          ],
+          "media" => {
+            "type" => "application/json"
+          },
+          "pathStart" => "/",
+          "readOnly" => false
+        }
+      },
+      "properties" => {
+        "app" => {
+          "$ref" => "#/definitions/app"
+        },
+      },
+      "links" => [
+        {
+          "href" => "http://example.com",
+          "rel" => "self"
+        }
+      ]
+    }
+  end
+end

data/test/json_pointer/evaluator_test.rb

@@ -0,0 +1,69 @@
+require "test_helper"
+
+require "json_pointer"
+require "json_schema"
+
+describe JsonPointer::Evaluator do
+  before do
+    @evaluator = JsonPointer::Evaluator.new(data)
+  end
+
+  it "evaluates pointers according to spec" do
+    assert_equal data,           @evaluator.evaluate("")
+    assert_equal ["bar", "baz"], @evaluator.evaluate("/foo")
+    assert_equal "bar",          @evaluator.evaluate("/foo/0")
+    assert_equal 0,              @evaluator.evaluate("/")
+    assert_equal 1,              @evaluator.evaluate("/a~1b")
+    assert_equal 2,              @evaluator.evaluate("/c%d")
+    assert_equal 3,              @evaluator.evaluate("/e^f")
+    assert_equal 4,              @evaluator.evaluate("/g|h")
+    assert_equal 5,              @evaluator.evaluate("/i\\j")
+    assert_equal 6,              @evaluator.evaluate("/k\"l")
+    assert_equal 7,              @evaluator.evaluate("/ ")
+    assert_equal 8,              @evaluator.evaluate("/m~0n")
+  end
+
+  it "takes a leading #" do
+    assert_equal 0, @evaluator.evaluate("#/")
+  end
+
+  it "returns nils on missing values" do
+    assert_nil @evaluator.evaluate("/bar")
+  end
+
+  it "raises when a path doesn't being with /" do
+    e = assert_raises(ArgumentError) { @evaluator.evaluate("foo") }
+    assert_equal %{Path must begin with a leading "/": foo.}, e.message
+    e = assert_raises(ArgumentError) { @evaluator.evaluate("#foo") }
+    assert_equal %{Path must begin with a leading "/": #foo.}, e.message
+  end
+
+  it "raises when a non-digit is specified on an array" do
+    e = assert_raises(ArgumentError) { @evaluator.evaluate("/foo/bar") }
+    assert_equal %{Key operating on an array must be a digit or "-": bar.},
+      e.message
+  end
+
+  it "can evaluate on a schema object" do
+    schema = JsonSchema.parse!(DataScaffold.schema_sample)
+    evaluator = JsonPointer::Evaluator.new(schema)
+    res = evaluator.evaluate("#/definitions/app/definitions/contrived/allOf/0")
+    assert_kind_of JsonSchema::Schema, res
+    assert 30, res.max_length
+  end
+
+  def data
+   {
+      "foo"  => ["bar", "baz"],
+      ""     => 0,
+      "a/b"  => 1,
+      "c%d"  => 2,
+      "e^f"  => 3,
+      "g|h"  => 4,
+      "i\\j" => 5,
+      "k\"l" => 6,
+      " "    => 7,
+      "m~n"  => 8
+   }
+  end
+end

data/test/json_reference/reference_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+require "json_reference"
+
+describe JsonReference::Reference do
+  it "expands a reference without a URI" do
+    ref = reference("#/definitions")
+    assert_nil ref.uri
+    assert_equal "#/definitions", ref.pointer
+  end
+
+  it "expands a reference with a URI" do
+    ref = reference("http://example.com#/definitions")
+    assert_equal URI.parse("http://example.com"), ref.uri
+    assert_equal "#/definitions", ref.pointer
+  end
+
+  it "expands just a root sign" do
+    ref = reference("#")
+    assert_nil ref.uri
+    assert_equal "#", ref.pointer
+  end
+
+  it "expands a URI with just a root sign" do
+    ref = reference("http://example.com#")
+    assert_equal URI.parse("http://example.com"), ref.uri
+    assert_equal "#", ref.pointer
+  end
+
+  it "normalizes pointers by adding a root sign prefix" do
+    ref = reference("/definitions")
+    assert_nil ref.uri
+    assert_equal "#/definitions", ref.pointer
+  end
+
+  it "normalizes pointers by stripping a trailing slash" do
+    ref = reference("#/definitions/")
+    assert_nil ref.uri
+    assert_equal "#/definitions", ref.pointer
+  end
+
+  def reference(str)
+    JsonReference::Reference.new(str)
+  end
+end

data/test/json_schema/attribute_test.rb

@@ -0,0 +1,121 @@
+require "test_helper"
+
+require "json_schema"
+
+describe JsonSchema::Attributes do
+  it "defines copyable attributes" do
+    obj = TestAttributes.new
+    obj.copyable = "foo"
+    assert_equal "foo", obj.copyable
+    assert_includes obj.class.copyable_attrs, :@copyable
+  end
+
+  it "defines schema attributes" do
+    obj = TestAttributes.new
+    obj.schema = "foo"
+    assert_equal "foo", obj.schema
+    assert_equal({:schema => :schema, :named => :schema_named, :cached => :cached},
+      obj.class.schema_attrs)
+  end
+
+  it "defines attributes with default readers" do
+    obj = TestAttributes.new
+    assert_equal [], obj.copyable_default
+
+    assert_equal "application/json", obj.copyable_default_with_string
+
+    hash = obj.copyable_default_with_object
+    assert_equal({}, hash)
+    ex = if defined?(FrozenError)
+           FrozenError
+         else
+           RuntimeError
+         end
+
+    assert_raises(ex) do
+      hash[:x] = 123
+    end
+
+    # This is a check to make sure that the new object is not the same object
+    # as the one that we just mutated above. When assigning defaults the module
+    # should dup any common data strcutures that it puts in here.
+    obj = TestAttributes.new
+    hash = obj.copyable_default_with_object
+    assert_equal({}, hash)
+  end
+
+  it "inherits attributes when so instructed" do
+    obj = TestAttributesDescendant.new
+    assert_includes obj.class.copyable_attrs, :@copyable
+  end
+
+  it "allows schema attributes to be indexed but not others" do
+    obj = TestAttributes.new
+
+    obj.copyable = "non-schema"
+    obj.schema = "schema"
+
+    assert_raises NoMethodError do
+      assert_nil obj[:copyable]
+    end
+
+    assert_equal "schema", obj[:schema]
+  end
+
+  it "copies attributes with #copy_from" do
+    obj = TestAttributes.new
+
+    obj.copyable = "copyable"
+    obj.schema = "schema"
+
+    obj2 = TestAttributes.new
+    obj2.copy_from(obj)
+
+    assert_equal "copyable", obj2.copyable
+    assert_equal "schema", obj2.schema
+  end
+
+  it "initializes attributes with #initialize_attrs" do
+    obj = TestAttributes.new
+
+    # should produce a nil value *without* a Ruby warning
+    assert_nil obj.copyable
+    assert_nil obj.schema
+  end
+
+  it "cleans cached values when assigning parent attribute" do
+    obj = TestAttributes.new
+
+    obj.cached = "test"
+    assert_equal "test_123", obj.cached_parsed
+
+    obj.cached = "other"
+    assert_equal "other_123", obj.cached_parsed
+  end
+
+  class TestAttributes
+    include JsonSchema::Attributes
+
+    def initialize
+      initialize_attrs
+    end
+
+    attr_copyable :copyable
+
+    attr_schema :schema
+    attr_schema :schema_named, :schema_name => :named
+
+    attr_schema :cached, :clear_cache => :@cached_parsed
+    def cached_parsed
+      @cached_parsed ||= "#{cached}_123"
+    end
+
+    attr_copyable :copyable_default, :default => []
+    attr_copyable :copyable_default_with_string, :default => "application/json"
+    attr_copyable :copyable_default_with_object, :default => {}
+  end
+
+  class TestAttributesDescendant < TestAttributes
+    inherit_attrs
+  end
+end