nidyx 0.1.0

data/test/nidyx/objc/test_property.rb

@@ -0,0 +1,237 @@
+require "minitest/autorun"
+require "nidyx"
+require "nidyx/property"
+require "nidyx/objc/property"
+
+class TestObjCProperty < Minitest::Test
+
+  def test_is_obj
+    assert_equal(true, simple_property("array").is_obj?)
+    assert_equal(false, simple_property("boolean").is_obj?)
+    assert_equal(false, simple_property("integer").is_obj?)
+    assert_equal(false, simple_property("number").is_obj?)
+    assert_equal(true, simple_property(%w(boolean null)).is_obj?)
+    assert_equal(true, simple_property(%w(integer null)).is_obj?)
+    assert_equal(true, simple_property(%w(number null)).is_obj?)
+    assert_equal(true, simple_property("string").is_obj?)
+    assert_equal(true, simple_property("object").is_obj?)
+    assert_equal(true, simple_property("null").is_obj?)
+  end
+
+  def test_simple_array
+    obj = { "type" => "array" }
+    p = property(obj, false)
+    assert_equal(:array, p.type)
+    assert_equal(nil, p.getter_override)
+    assert_equal([], p.protocols)
+    assert_equal(false, p.has_protocols?)
+
+    # optional array
+    p = property(obj, true)
+    assert_equal(:array, p.type)
+    assert_equal(["Optional"], p.protocols)
+    assert_equal(true, p.has_protocols?)
+  end
+
+  def test_typed_optional_array
+    obj = { "type" => ["array", "null"] }
+    p = property(obj, false)
+    assert_equal(:array, p.type)
+    assert_equal(["Optional"], p.protocols)
+  end
+
+  def test_boolean
+    obj = { "type" => "boolean" }
+    p = property(obj, false)
+    assert_equal(:boolean, p.type)
+
+    # optional boolean
+    p = property(obj, true)
+    assert_equal(:number_obj, p.type)
+  end
+
+  def test_typed_optional_boolean
+    obj = { "type" => ["boolean", "null"] }
+    p = property(obj, false)
+    assert_equal(:number_obj, p.type)
+  end
+
+  def test_integer
+    obj = { "type" => "integer" }
+    p = property(obj, false)
+    assert_equal(:integer, p.type)
+
+    p = property(obj, true)
+    assert_equal(:number_obj, p.type)
+    assert_equal(["Optional"], p.protocols)
+  end
+
+  def test_unsigned_integer
+    obj = { "type" => "integer", "minimum" => 0 }
+    p = property(obj, false)
+    assert_equal(:unsigned, p.type)
+  end
+
+  def test_typed_optional_integer
+    obj = { "type" => ["integer", "null"] }
+    p = property(obj, false)
+    assert_equal(:number_obj, p.type)
+    assert_equal(["Optional"], p.protocols)
+  end
+
+  def test_number
+    obj = { "type" => "number" }
+    p = property(obj, false)
+    assert_equal(:number, p.type)
+
+    p = property(obj, true)
+    assert_equal(:number_obj, p.type)
+  end
+
+  def test_typed_optional_number
+    obj = { "type" => ["number", "null"] }
+    p = property(obj, false)
+    assert_equal(:number_obj, p.type)
+  end
+
+  def test_string
+    obj = { "type" => "string" }
+    p = property(obj, false)
+    assert_equal(:string, p.type)
+
+    p = property(obj, true)
+    assert_equal(:string, p.type)
+  end
+
+  def test_typed_optional_string
+    obj = { "type" => ["string", "null"] }
+    p = property(obj, false)
+    assert_equal(:string, p.type)
+  end
+
+  def test_object
+    obj = {
+      "type" => "object",
+      "properties" => {}
+    }
+
+    p = property(obj, false)
+    assert_equal(:object, p.type)
+  end
+
+  def test_multiple_numeric_types
+    obj = { "type" => ["number", "integer", "boolean"] }
+    p = property(obj, false)
+    assert_equal(:number_obj, p.type)
+  end
+
+  def test_typed_optional_multiple_numeric_types
+    obj = { "type" => ["number", "integer", "boolean", "null"] }
+    p = property(obj, false)
+    assert_equal(:number_obj, p.type)
+    assert_equal(["Optional"], p.protocols)
+  end
+
+  def test_multiple_disparate_types
+    obj = { "type" => ["object", "number"] }
+    p = property(obj, false)
+    assert_equal(:id, p.type)
+  end
+
+  def test_typed_optional_multiple_disparate_types
+    obj = { "type" => ["object", "number", "null"] }
+    p = property(obj, false)
+    assert_equal(:id, p.type)
+  end
+
+  def test_simple_numbers
+    obj = { "type" => [ "integer", "number" ] }
+    p = property(obj, false)
+    assert_equal(:number, p.type)
+
+    p = property(obj, true)
+    assert_equal(:number_obj, p.type)
+  end
+
+  def test_typed_optional_simple_numbers
+    obj = { "type" => [ "integer", "number", "null" ] }
+    p = property(obj, false)
+    assert_equal(:number_obj, p.type)
+  end
+
+  def test_integer_enum
+    obj = { "enum" => [1, 2] }
+    p = property(obj, false)
+    assert_equal(:integer, p.type)
+
+    p = property(obj, true)
+    assert_equal(:number_obj, p.type)
+    assert_equal(["Optional"], p.protocols)
+  end
+
+  def test_string_enum
+    obj = { "enum" => ["a", "b"] }
+    p = property(obj, false)
+    assert_equal(:string, p.type)
+  end
+
+  def test_typed_optional_enum
+    obj = { "enum" => [1, 2, nil] }
+    p = property(obj, false)
+    assert_equal(:number_obj, p.type)
+    assert_equal(["Optional"], p.protocols)
+  end
+
+  def test_single_element_array_type
+    obj = { "type" => ["integer"] }
+    p = property(obj, false)
+    assert_equal(:integer, p.type)
+  end
+
+  def test_anonymous_object
+    obj = { "type" => "object" }
+    p = property(obj, false)
+    assert_equal(:id, p.type)
+  end
+
+  def test_unsafe_getter
+    obj = { "type" => "integer" }
+    p = Nidyx::ObjCProperty.new(Nidyx::Property.new("newInt", nil, false, obj))
+    assert_equal(", getter=getNewInt", p.getter_override)
+  end
+
+  def test_protocols
+    obj = {
+      "type" => "array",
+      COLLECTION_TYPES_KEY => ["SomeModel", "OtherModel"]
+    }
+
+    p = property(obj, false)
+    assert_equal(true, p.has_protocols?)
+    assert_equal("SomeModel, OtherModel", p.protocols_string)
+    assert_equal(%w(SomeModel OtherModel), p.protocols)
+
+    p = property(obj, true)
+    assert_equal(true, p.has_protocols?)
+    assert_equal("SomeModel, OtherModel, Optional", p.protocols_string)
+    assert_equal(%w(SomeModel OtherModel Optional), p.protocols)
+  end
+
+  def test_unsupported_types_enum
+    assert_raises(Nidyx::ObjCProperty::UnsupportedEnumTypeError) do
+      obj = { "enum" => ["a", {}] }
+      Nidyx::ObjCProperty.new(Nidyx::Property.new("i", nil, false, obj))
+    end
+  end
+
+  private
+
+  def simple_property(type)
+    obj = { "type" => type }
+    Nidyx::ObjCProperty.new(Nidyx::Property.new("p", nil, false, obj))
+  end
+
+  def property(obj, optional, class_name = nil)
+    Nidyx::ObjCProperty.new(Nidyx::Property.new("name", class_name, optional, obj))
+  end
+end

data/test/nidyx/test_common.rb

@@ -0,0 +1,102 @@
+require "minitest/autorun"
+require "nidyx"
+require "nidyx/common"
+
+include Nidyx::Common
+
+class TestCommon < Minitest::Test
+  def test_class_name
+    assert_equal("DKResponseModel", class_name("DK", "response"))
+    assert_equal("DKModel", class_name("DK", nil))
+    assert_equal("DKLargeButtonModel", class_name("DK", "large_button"))
+  end
+
+  def test_class_name_from_path
+    schema = {
+      "type" => "object",
+      "properties" => {
+        "obj" => { "$ref" => "#/definitions/obj" }
+      },
+      "definitions" => {
+        "obj" => {
+          "type" => "object",
+          "properties" => {
+            "name" => { "type" => "string" }
+          }
+        }
+      }
+    }
+
+    path = ["definitions", "obj"]
+    assert_equal("DKObjModel", class_name_from_path("DK", path, schema))
+    # empty
+    assert_equal("DKModel", class_name_from_path("DK", [], schema))
+  end
+
+  def test_class_name_from_path_overrides
+    schema = {
+      "type" => "object",
+      "properties" => {
+        "obj" => {
+          "type" => "object",
+          "nameOverride" => "otherObject",
+          "properties" => {
+            "subObject" => {
+              "type" => "object",
+              "nameOverride" => "otherSubObject",
+              "properties" => {
+                "count" => { "type" => "integer" }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    path = ["properties", "obj"]
+    assert_equal("DKOtherObjectModel", class_name_from_path("DK", path, schema))
+    path = ["properties", "obj", "properties", "subObject"]
+    assert_equal("DKOtherSubObjectModel", class_name_from_path("DK", path, schema))
+  end
+
+  def test_object_at_path
+    schema = {
+      "type" => "object",
+      "properties" => {
+        "value" =>  { "$ref" => "#/definitions/obj" }
+      },
+      "definitions" => {
+        "obj" => {
+          "type" => "object",
+          "properties" => {
+            "name" => { "type" => "string" },
+            "count" => { "type" => "integer" }
+          }
+        }
+      }
+    }
+
+    obj = object_at_path(["properties", "value"], schema)
+    assert_equal("#/definitions/obj", obj["$ref"])
+
+    obj = object_at_path(["definitions", "obj"], schema)
+    assert_equal("object", obj["type"])
+    assert_equal("string", obj["properties"]["name"]["type"])
+
+    obj = object_at_path(["definitions", "obj", "properties", "count"], schema)
+    assert_equal("integer", obj["type"])
+  end
+
+  def test_object_at_path_raises
+    schema = {
+      "type" => "object",
+      "properties" => {
+        "value" => { "type" => "string" }
+      }
+    }
+
+    assert_raises(Nidyx::Common::NoObjectAtPathError) do
+      object_at_path(["bad", "path"], schema)
+    end
+  end
+end

data/test/nidyx/test_comparison.rb

@@ -0,0 +1,64 @@
+require "minitest/autorun"
+require "fileutils"
+
+class TestComparison < Minitest::Test
+  def setup
+    FileUtils.mkdir_p(TMP_PATH)
+  end
+
+  def teardown
+    FileUtils.rm_rf(TMP_PATH)
+  end
+
+  def test_simple_properties
+    validate_files("simple_properties")
+  end
+
+  def test_complex_properties
+    validate_files("complex_properties")
+  end
+
+  def test_defs_and_refs
+    validate_files("defs_and_refs")
+  end
+
+  private
+
+  ROOT = File.absolute_path(File.join(File.dirname(__FILE__), "../.."))
+  TMP_PATH = File.join(ROOT, "tmp")
+  EXAMPLES_PATH = File.join(ROOT, "examples")
+  PREFIX = "Example"
+
+  def validate_files(example_name)
+    run_generate(example_name)
+
+    Dir.foreach(TMP_PATH) do |f|
+      validate_file(example_name, f) unless [".", ".."].include?(f)
+    end
+  end
+
+  def run_generate(example_name)
+    cmd = "bundle exec nidyx " <<
+          example_schema_path(example_name) <<
+          " #{PREFIX} #{TMP_PATH} -n --json-model"
+
+    assert(false) unless system(cmd)
+  end
+
+  def validate_file(ename, fname)
+      assert_equal(IO.read(example_file_path(ename, fname)),
+                   IO.read(tmp_file_path(fname)))
+  end
+
+  def tmp_file_path(file_name)
+    File.join(TMP_PATH, file_name)
+  end
+
+  def example_file_path(example_name, file_name)
+    File.join(EXAMPLES_PATH, example_name, file_name)
+  end
+
+  def example_schema_path(example_name)
+    File.join(EXAMPLES_PATH, example_name, "#{example_name}.json.schema")
+  end
+end