jat 0.0.1 → 0.0.3

data/test/lib/jat/plugins/simple_api/lib/params/parse_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApi::Params::Parse" do
+  before do
+    Jat::Plugins.load_plugin :simple_api
+  end
+
+  def parse(str)
+    Jat::Plugins::SimpleApi::Params::Parse.new(str).parse
+  end
+
+  it "returns empty hash when nil provided" do
+    assert_equal({}, parse(nil))
+  end
+
+  it "returns empty hash when empty string provided" do
+    assert_equal({}, parse(""))
+  end
+
+  it "parses single field" do
+    assert_equal({id: {}}, parse("id"))
+  end
+
+  it "parses multiple fields" do
+    assert_equal({id: {}, name: {}}, parse("id,name"))
+  end
+
+  it "parses single resource with single field" do
+    assert_equal({users: {id: {}}}, parse("users(id)"))
+  end
+
+  it "parses fields started with open PAREN" do
+    assert_equal({users: {id: {}}}, parse("(users(id))"))
+  end
+
+  it "parses single resource with multiple fields" do
+    assert_equal({users: {id: {}, name: {}}}, parse("users(id,name)"))
+  end
+
+  it "parses multiple resources with fields" do
+    fields = "id,posts(title,text),news(title,text)"
+    resp = {
+      id: {},
+      posts: {title: {}, text: {}},
+      news: {title: {}, text: {}}
+    }
+
+    assert_equal(resp, parse(fields))
+  end
+
+  it "parses included resources" do
+    fields = "id,posts(title,text,comments(author(name),comment))"
+    resp = {
+      id: {},
+      posts: {
+        title: {},
+        text: {},
+        comments: {
+          author: {
+            name: {}
+          },
+          comment: {}
+        }
+      }
+    }
+
+    assert_equal(resp, parse(fields))
+  end
+end

data/test/lib/jat/plugins/simple_api/lib/response_test.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApi::Response" do
+  let(:base_class) { Class.new(Jat) { plugin :simple_api } }
+
+  it "returns empty hash when nothing to serialize" do
+    empty_serializer = Class.new(base_class)
+
+    assert_equal({}, empty_serializer.to_h(nil))
+  end
+
+  it "returns correct structure with meta" do
+    empty_serializer = Class.new(base_class)
+
+    assert_equal({meta: {any: :thing}}, empty_serializer.to_h(nil, meta: {any: :thing}))
+  end
+
+  it "returns correct structure with data" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |_| "STRING" }
+    end
+
+    assert_equal({id: "STRING"}, str_serializer.to_h("STRING"))
+  end
+
+  it "returns correct structure when parameter `many` defined manually" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[:foo] }
+    end
+
+    # By default hash is interpreted as `many: true` as it is Enumerable
+    obj = {foo: :bar}
+    context = {many: false}
+
+    assert_equal({id: :bar}, str_serializer.to_h(obj, context))
+  end
+
+  it "returns correct structure with array data" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal(
+      [{id: "1"}, {id: "2"}],
+      str_serializer.to_h(%w[1 2])
+    )
+  end
+
+  it "raises error when trying to add meta to response without root key" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    error = assert_raises(Jat::Error) { str_serializer.to_h("1", meta: {foo: :bar}) }
+    assert_equal "Response must have a root key to add metadata", error.message
+
+    error = assert_raises(Jat::Error) { str_serializer.to_h(["1"], meta: {foo: :bar}) }
+    assert_equal "Response must have a root key to add metadata", error.message
+  end
+
+  it "returns correct structure with array data" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal(
+      [{id: "1"}, {id: "2"}],
+      str_serializer.to_h(%w[1 2])
+    )
+  end
+
+  it "returns correct structure with one object with root key" do
+    str_serializer = Class.new(base_class) do
+      root(:digit)
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal({digit: {id: "1"}}, str_serializer.to_h("1"))
+  end
+
+  it "returns correct structure with list with root key" do
+    str_serializer = Class.new(base_class) do
+      root(:digits)
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal(
+      {digits: [{id: "1"}, {id: "2"}]},
+      str_serializer.to_h(%w[1 2])
+    )
+  end
+
+  it "returns correct structures root_for_one and root_for_many keys" do
+    str_serializer = Class.new(base_class) do
+      root(:not_used)
+      root_for_one(:digit)
+      root_for_many(:digits)
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal({digit: {id: "1"}}, str_serializer.to_h("1"))
+    assert_equal({digits: [{id: "1"}]}, str_serializer.to_h(["1"]))
+  end
+
+  it "returns correct structures when root is overwritten" do
+    str_serializer = Class.new(base_class) do
+      root(:root)
+      root_for_one(:root)
+      root_for_many(:root)
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal({foo: {id: "1"}}, str_serializer.to_h("1", root: :foo))
+    assert_equal({foo: [{id: "1"}]}, str_serializer.to_h(["1"], root: :foo))
+  end
+
+  it "returns correct structure with data and meta" do
+    str_serializer = Class.new(base_class) do
+      root(:root)
+      config[:meta] = {version: "1.2.3"}
+
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal(
+      {root: {id: "1"}, meta: {any: :thing, version: "1.2.3"}},
+      str_serializer.to_h("1", meta: {any: :thing})
+    )
+
+    assert_equal(
+      {root: [{id: "1"}], meta: {any: :thing, version: "1.2.3"}},
+      str_serializer.to_h(["1"], meta: {any: :thing})
+    )
+  end
+
+  it "returns correct structure with data multiple attributes" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+      attribute :length
+    end
+
+    assert_equal({id: "1", length: 1}, str_serializer.to_h("1"))
+  end
+
+  it "returns correct structure with has-one relationship" do
+    int_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :length, serializer: int_serializer, exposed: true
+    end
+
+    assert_equal({id: "S", length: {id: 6}}, str_serializer.to_h("STRING"))
+  end
+
+  it "returns correct structure when children serializer defined as lambda" do
+    int_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :length, serializer: -> { int_serializer }, exposed: true
+    end
+
+    assert_equal({id: "S", length: {id: 6}}, str_serializer.to_h("STRING"))
+  end
+
+  it "does not return has-one relationship when not exposed" do
+    int_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :length, serializer: int_serializer, exposed: false
+    end
+
+    assert_equal({id: "S"}, str_serializer.to_h("STRING"))
+  end
+
+  it "returns nil as empty has-one relationship" do
+    int_serializer = Class.new(base_class)
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute(:length, serializer: int_serializer, exposed: true) { |_obj| nil }
+    end
+
+    assert_equal(
+      {id: "S", length: nil},
+      str_serializer.to_h("STRING")
+    )
+  end
+
+  it "returns correct structure with has-one relationship with attributes" do
+    int_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+      attribute(:next) { |obj| obj + 1 }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :length, serializer: int_serializer, exposed: true
+    end
+
+    assert_equal(
+      {id: "S", length: {id: 6, next: 7}},
+      str_serializer.to_h("STRING")
+    )
+  end
+
+  it "returns empty array as empty has-many relationship" do
+    chr_serializer = Class.new(base_class)
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |_obj| "id" }
+      attribute :chars, serializer: chr_serializer, many: true, exposed: true
+    end
+
+    assert_equal({id: "id", chars: []}, str_serializer.to_h(""))
+  end
+
+  it "returns correct structure with has-many relationship" do
+    chr_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :chars, serializer: chr_serializer, many: true, exposed: true
+    end
+
+    assert_equal(
+      {id: "a", chars: [{id: "a"}, {id: "b"}]},
+      str_serializer.to_h("ab")
+    )
+  end
+
+  it "automatically checks if nested relationship is enumerable or single object" do
+    chr_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    int_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :chars, serializer: chr_serializer, exposed: true, many: true
+      attribute :length, serializer: int_serializer, exposed: true, many: false
+    end
+
+    assert_equal(
+      {id: "a", chars: [{id: "a"}, {id: "b"}], length: {id: 2}},
+      str_serializer.to_h("ab")
+    )
+  end
+
+  it "returns correct structure with has-many relationship with attributes" do
+    chr_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+      attribute :next
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :chars, serializer: chr_serializer, many: true, exposed: true
+    end
+
+    assert_equal(
+      {id: "a", chars: [{id: "a", next: "b"}, {id: "b", next: "c"}]},
+      str_serializer.to_h("ab")
+    )
+  end
+
+  it "accepts fields" do
+    # All fields are not exposed in this serializers,
+    # We will show only attributes provided in `fields` param
+    chr_serializer = Class.new(base_class) do
+      attribute(:id, exposed: false) { |obj| obj }
+      attribute :next, exposed: false
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id, exposed: false) { |obj| obj }
+      attribute :chars, serializer: chr_serializer, many: true, exposed: false
+    end
+
+    assert_equal(
+      {chars: [{next: "b"}, {next: "c"}]},
+      str_serializer.to_h("ab", params: {fields: "chars(next)"})
+    )
+  end
+
+  it "does not overwrite manually added meta" do
+    str_serializer = Class.new(base_class) do
+      root(:root)
+      config[:meta] = {version: "1.2.3"}
+
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal(
+      {root: {id: "1"}, meta: {version: "2.0.0"}},
+      str_serializer.to_h("1", meta: {version: "2.0.0"})
+    )
+  end
+
+  it "allows to provide lambda as meta key" do
+    str_serializer = Class.new(base_class) do
+      root(:root)
+      config[:meta] = {
+        obj: ->(obj, _context) { obj },
+        context: ->(_obj, context) { context },
+        time: ->(_obj, _context) { Time.new(2020, 1, 1) }
+      }
+
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal(
+      {root: {id: "1"}, meta: {obj: "1", context: {foo: :bar}, time: Time.new(2020, 1, 1)}},
+      str_serializer.to_h("1", foo: :bar)
+    )
+  end
+
+  it "does not adds nil meta" do
+    str_serializer = Class.new(base_class) do
+      root(:root)
+      config[:meta] = {foo: nil, bar: proc {}}
+
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal({root: {id: "1"}}, str_serializer.to_h("1", bazz: nil))
+  end
+end

data/test/lib/jat/plugins/simple_api/simple_api_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApi" do
+  before { @plugin = Jat::Plugins.load_plugin(:simple_api) }
+
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.plugin(plugin)
+    new_class.root :data
+    new_class.attribute :id, key: :itself
+    new_class
+  end
+
+  let(:plugin) { @plugin }
+
+  describe ".after_load" do
+    it "loads _json_api_activerecord plugin if activerecord option provided" do
+      jat_class = Class.new(Jat)
+      jat_class.expects(:plugin).with(:_json_api_activerecord, activerecord: true)
+
+      Jat::Plugins.after_load(plugin, jat_class, activerecord: true)
+    end
+  end
+
+  describe "InstanceMethods" do
+    let(:jat) { jat_class.new("JAT", {}) }
+
+    describe "#to_h" do
+      it "returns response in a simple-api format" do
+        expected_result = {data: {id: "JAT"}}
+        assert_equal expected_result, jat.to_h
+      end
+    end
+
+    describe "#traversal_map" do
+      it "returns memorized traversal_map hash" do
+        assert_equal jat.traversal_map.class, Hash
+        assert_same jat.traversal_map, jat.traversal_map
+      end
+    end
+  end
+
+  describe "ClassMethods" do
+    describe ".inherited" do
+      it "inherits root" do
+        child = Class.new(jat_class)
+        assert_equal :data, child.root
+      end
+    end
+
+    describe ".root" do
+      it "saves and returns current root" do
+        assert_equal :data, jat_class.root
+      end
+
+      it "symbolizes root" do
+        jat_class.root "users"
+        assert_equal :users, jat_class.root
+      end
+    end
+
+    describe ".meta_key" do
+      it "returns default meta_key" do
+        assert_equal :meta, jat_class.meta_key
+      end
+
+      it "saves and returns meta key" do
+        jat_class.meta_key :metadata
+        assert_equal :metadata, jat_class.meta_key
+        assert_same jat_class.meta_key, jat_class.meta_key
+      end
+
+      it "symbolizes meta key" do
+        jat_class.meta_key "metadata"
+        assert_equal :metadata, jat_class.meta_key
+      end
+    end
+  end
+end

data/test/lib/jat/plugins/to_str/to_str_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::ToStr" do
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.plugin(:to_str)
+    new_class.class_exec do
+      def to_h
+        {object => context}
+      end
+    end
+
+    new_class
+  end
+
+  describe "Jat" do
+    describe ".to_str" do
+      it "returns json string of to_h" do
+        assert_equal '{"obj":"ctx"}', jat_class.to_str("obj", "ctx")
+      end
+
+      it "returns json string of to_h with default empty hash context" do
+        assert_equal '{"obj":{}}', jat_class.to_str("obj")
+      end
+
+      it "returns result serialized with given in config serializer" do
+        jat_class.config[:to_str] = ->(data) { data.inspect }
+        assert_equal '{"obj"=>"ctx"}', jat_class.to_str("obj", "ctx")
+      end
+
+      it "accepts to_str config option when loading plugin" do
+        new_class = Class.new(Jat)
+        new_class.plugin(:to_str, to_str: ->(data) { data.inspect })
+        new_class.class_exec do
+          def to_h
+            {object => context}
+          end
+        end
+
+        assert_equal '{"obj"=>"ctx"}', new_class.to_str("obj", "ctx")
+      end
+    end
+
+    describe "#to_str" do
+      it "returns json string of to_h" do
+        assert_equal '{"obj":"ctx"}', jat_class.new("obj", "ctx").to_str
+      end
+    end
+  end
+end

data/test/lib/jat/presenter_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat::Presenter do
+  let(:jat_class) { Class.new(Jat) }
+  let(:presenter_class) { jat_class::Presenter }
+
+  describe ".jat_class=" do
+    it "assigns @jat_class" do
+      presenter_class.jat_class = :foo
+      assert_equal :foo, presenter_class.instance_variable_get(:@jat_class)
+    end
+  end
+
+  describe ".jat_class" do
+    it "returns self @jat_class" do
+      assert_same jat_class, presenter_class.instance_variable_get(:@jat_class)
+      assert_same jat_class, presenter_class.jat_class
+    end
+  end
+
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{jat_class}::Presenter", presenter_class.inspect
+    end
+  end
+
+  describe ".add_method" do
+    let(:presenter) { presenter_class.new("OBJECT", "CONTEXT") }
+
+    it "adds method by providing block without variables" do
+      presenter_class.add_method(:foo, proc { [object, context] })
+      assert_equal %w[OBJECT CONTEXT], presenter.foo
+    end
+
+    it "adds method by providing block with one variables" do
+      presenter_class.add_method(:foo, proc { |obj| [obj, object, context] })
+      assert_equal %w[OBJECT OBJECT CONTEXT], presenter.foo
+    end
+
+    it "adds method by providing block with two variables" do
+      presenter_class.add_method(:foo, proc { |obj, ctx| [obj, ctx, object, context] })
+      assert_equal %w[OBJECT CONTEXT OBJECT CONTEXT], presenter.foo
+    end
+
+    it "raises error when block has more than two variables" do
+      error = assert_raises(Jat::Error) { presenter_class.add_method(:foo, proc { |_a, _b, _c| }) }
+      assert_equal "Invalid block arguments count", error.message
+    end
+  end
+
+  describe "#initialize" do
+    it "initializes object presenter with provided object and context" do
+      presenter = presenter_class.new("OBJ", "CTX")
+
+      assert_equal "OBJ", presenter.object
+      assert_equal "CTX", presenter.context
+    end
+  end
+end

data/test/lib/jat/utils/enum_deep_dup_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat::EnumDeepDup do
+  describe ".call" do
+    it "makes deep dup of hash" do
+      hash = {key1: {key11: {key111: :value111}}, key2: [{key22: {key222: :value222}}]}
+      dup = Jat::EnumDeepDup.call(hash)
+
+      assert_equal hash, dup
+
+      refute_same hash, dup
+      refute_same hash[:key1], dup[:key1]
+      refute_same hash[:key1][:key11], dup[:key1][:key11]
+
+      refute_same hash[:key2], dup[:key2]
+      refute_same hash[:key2][0], dup[:key2][0]
+      refute_same hash[:key2][0][:key22], dup[:key2][0][:key22]
+    end
+
+    it "does not duplicates non-enumerable objects" do
+      hash = {key1: Jat, key2: [-> {}]}
+      dup = Jat::EnumDeepDup.call(hash)
+
+      assert_equal hash, dup
+      assert_same hash[:key1], dup[:key1]
+      assert_same hash[:key2][0], dup[:key2][0]
+    end
+  end
+end

data/test/lib/jat/utils/enum_deep_freeze_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat::EnumDeepFreeze do
+  describe ".call" do
+    it "deeply freezes provided hash" do
+      hash = {key1: {key11: {key111: :value111}}, key2: [{key22: {key222: :value222}}]}
+      Jat::EnumDeepFreeze.call(hash)
+
+      assert hash.frozen?
+      assert hash[:key1].frozen?
+      assert hash[:key1][:key11].frozen?
+
+      assert hash[:key2].frozen?
+      assert hash[:key2][0].frozen?
+      assert hash[:key2][0][:key22].frozen?
+    end
+
+    it "does not freezes non-enumerable objects" do
+      hash = {key1: Jat, key2: [-> {}]}
+      Jat::EnumDeepFreeze.call(hash)
+
+      refute hash[:key1].frozen?
+      refute hash[:key2][0].frozen?
+    end
+  end
+end