json_schema 0.0.7

data/test/data_scaffold.rb

@@ -0,0 +1,238 @@
+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"
+                },
+              }
+            }
+          ],
+          "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,60 @@
+require "test_helper"
+
+require "json_pointer"
+
+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(RuntimeError) { @evaluator.evaluate("foo") }
+    assert_equal %{Path must begin with a leading "/": foo.}, e.message
+    e = assert_raises(RuntimeError) { @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(RuntimeError) { @evaluator.evaluate("/foo/bar") }
+    assert_equal %{Key operating on an array must be a digit or "-": bar.},
+      e.message
+  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_schema/parser_test.rb

@@ -0,0 +1,230 @@
+require "test_helper"
+
+require "json_schema"
+
+describe JsonSchema::Parser do
+  it "parses the basic attributes of a schema" do
+    schema = parse
+    assert_nil schema.id
+    assert_equal "Example API", schema.title
+    assert_equal "An example API.", schema.description
+    assert_equal ["object"], schema.type
+    assert_equal "/", schema.uri
+  end
+
+  it "parses subschemas" do
+    schema = parse.definitions["app"]
+    assert_nil schema.reference
+    assert_equal "App", schema.title
+    assert_equal "An app.", schema.description
+    assert_equal "schemata/app", schema.id
+    assert_equal ["object"], schema.type
+    assert_equal "/schemata/app", schema.uri
+    refute_nil schema.parent
+  end
+
+  it "parses sub-subschemas" do
+    schema = parse.definitions["app"].definitions["name"]
+    assert_nil schema.reference
+    assert_equal "hello-world", schema.default
+    assert_equal "unique name of app", schema.description
+    assert_equal ["string"], schema.type
+    assert_equal "/schemata/app", schema.uri
+    refute_nil schema.parent
+  end
+
+  it "parses references" do
+    schema = parse.properties["app"]
+    refute_nil schema.reference
+    assert_nil schema.reference.uri
+    assert_equal "#/definitions/app", schema.reference.pointer
+    refute_nil schema.parent
+  end
+
+  it "parses enum validation" do
+    schema = parse.definitions["app"].definitions["visibility"]
+    assert_equal ["private", "public"], schema.enum
+  end
+
+  it "parses array validations" do
+    schema = parse.definitions["app"].definitions["flags"]
+    assert_equal /^[a-z][a-z\-]*[a-z]$/, schema.items.pattern
+    assert_equal 1, schema.min_items
+    assert_equal 10, schema.max_items
+    assert_equal true, schema.unique_items
+  end
+
+  it "parses array items tuple validation" do
+    pointer("#/definitions/app/definitions/flags").merge!(
+      "items" => [
+        { "enum" => ["bamboo", "cedar"] },
+        { "enum" => ["http", "https"] }
+      ]
+    )
+    schema = parse.definitions["app"].definitions["flags"]
+    assert_equal ["bamboo", "cedar"], schema.items[0].enum
+    assert_equal ["http", "https"], schema.items[1].enum
+  end
+
+  it "parses integer validations" do
+    schema = parse.definitions["app"].definitions["id"]
+    assert_equal 0, schema.min
+    assert_equal true, schema.min_exclusive
+    assert_equal 10000, schema.max
+    assert_equal false, schema.max_exclusive
+    assert_equal 1, schema.multiple_of
+  end
+
+  it "parses number validations" do
+    schema = parse.definitions["app"].definitions["cost"]
+    assert_equal 0.0, schema.min
+    assert_equal false, schema.min_exclusive
+    assert_equal 1000.0, schema.max
+    assert_equal true, schema.max_exclusive
+    assert_equal 0.01, schema.multiple_of
+  end
+
+  it "parses the basic set of object validations" do
+    schema = parse.definitions["app"]
+    assert_equal false, schema.additional_properties
+    assert_equal 10, schema.max_properties
+    assert_equal 1, schema.min_properties
+    assert_equal ["name"], schema.required
+  end
+
+  it "parses the dependencies object validation" do
+    schema = parse.definitions["app"]
+    assert_equal ["ssl"], schema.dependencies["production"]
+    assert_equal 20.0, schema.dependencies["ssl"].properties["cost"].min
+  end
+
+  it "parses the patternProperties object validation" do
+    schema = parse.definitions["app"].definitions["config_vars"]
+    property = schema.pattern_properties.first
+    assert_equal /^\w+$/, property[0]
+    assert_equal ["null", "string"], property[1].type
+  end
+
+  # couldn't think of any non-contrived examples to work with here
+  it "parses the basic set of schema validations" do
+    schema = parse.definitions["app"].definitions["contrived"]
+    assert_equal 2, schema.all_of.count
+    assert_equal 2, schema.one_of.count
+    assert schema.not
+  end
+
+  it "parses the anyOf schema validation" do
+    schema = parse.definitions["app"].definitions["identity"]
+    assert_equal 2, schema.any_of.count
+    assert_equal "/schemata/app#/definitions/id", schema.any_of[0].reference.to_s
+    assert_equal "/schemata/app#/definitions/name", schema.any_of[1].reference.to_s
+  end
+
+  it "parses basic set of string validations" do
+    schema = parse.definitions["app"].definitions["name"]
+    assert_equal 30, schema.max_length
+    assert_equal 3, schema.min_length
+    assert_equal /^[a-z][a-z0-9-]{3,30}$/, schema.pattern
+  end
+
+  it "parses hypermedia links" do
+    pointer("#/definitions/app").merge!(
+      "links" => [
+        "description" => "Create a new app.",
+        "href" => "/apps",
+        "method" => "POST",
+        "rel" => "create",
+        "schema" => {
+          "properties" => {
+            "name" => {
+              "$ref" => "#/definitions/app/definitions/name"
+            },
+          }
+        }
+      ]
+    )
+    schema = parse.definitions["app"]
+    link = schema.links[0]
+    assert_equal schema, link.parent
+    assert_equal "Create a new app.", link.description
+    assert_equal "/apps", link.href
+    assert_equal :post, link.method
+    assert_equal "create", link.rel
+    assert_equal "#/definitions/app/definitions/name",
+      link.schema.properties["name"].reference.pointer
+  end
+
+  it "parses hypermedia media" do
+    pointer("#/definitions/app/media").merge!(
+      "binaryEncoding" => "base64",
+      "type"           => "image/png"
+    )
+    schema = parse.definitions["app"]
+    media = JsonSchema::Schema::Media.new
+    assert_equal "base64", schema.media.binary_encoding
+    assert_equal "image/png", schema.media.type
+  end
+
+  it "parses hypermedia pathStart" do
+    pointer("#/definitions/app").merge!(
+      "pathStart" => "/v2"
+    )
+    schema = parse.definitions["app"]
+    assert_equal "/v2", schema.path_start
+  end
+
+  it "parses hypermedia readOnly" do
+    pointer("#/definitions/app").merge!(
+      "readOnly" => true
+    )
+    schema = parse.definitions["app"]
+    assert_equal true, schema.read_only
+  end
+
+  it "errors on non-string ids" do
+    schema_sample["id"] = 4
+    refute parse
+    assert_includes error_messages, %{Expected "id" to be of type "string"; value was: 4.}
+  end
+
+  it "errors on non-string titles" do
+    schema_sample["title"] = 4
+    refute parse
+    assert_includes error_messages, %{Expected "title" to be of type "string"; value was: 4.}
+  end
+
+  it "errors on non-string descriptions" do
+    schema_sample["description"] = 4
+    refute parse
+    assert_includes error_messages, %{Expected "description" to be of type "string"; value was: 4.}
+  end
+
+  it "errors on non-array and non-string types" do
+    schema_sample["type"] = 4
+    refute parse
+    assert_includes error_messages, %{Expected "type" to be of type "array/string"; value was: 4.}
+  end
+
+  it "errors on unknown types" do
+    schema_sample["type"] = ["float", "double"]
+    refute parse
+    assert_includes error_messages, %{Unknown types: double, float.}
+  end
+
+  def error_messages
+    @parser.errors.map { |e| e.message }
+  end
+
+  def parse
+    @parser = JsonSchema::Parser.new
+    @parser.parse(schema_sample)
+  end
+
+  def pointer(path)
+    JsonPointer.evaluate(schema_sample, path)
+  end
+
+  def schema_sample
+    @schema_sample ||= DataScaffold.schema_sample
+  end
+end