jat 0.0.1 → 0.0.3

data/test/lib/jat/plugins/_preloads/lib/preloads_with_path_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::Preloads::PreloadsWithPath" do
+  before { Jat::Plugins.load_plugin(:_preloads) }
+
+  let(:described_class) { Jat::Plugins::Preloads::PreloadsWithPath }
+
+  it "returns provided preloads and path to last value" do
+    preloads = {a: {b: {c: {}}, d: {}}, e: {}}
+    new_preloads, path = described_class.call(preloads)
+
+    assert_equal({a: {b: {c: {}}, d: {}}, e: {}}, new_preloads)
+    assert_equal(%i[e], path)
+  end
+
+  it "returns provided preloads and path to marked with `!` value" do
+    preloads = {a: {b!: {c: {}}, d: {}}, e: {}}
+    new_preloads, path = described_class.call(preloads)
+
+    assert_equal({a: {b: {c: {}}, d: {}}, e: {}}, new_preloads)
+    assert_equal(%i[a b], path)
+  end
+
+  it "returns empty preloads and path when empty hash provided" do
+    preloads = {}
+    new_preloads, path = described_class.call(preloads)
+
+    assert_equal({}, new_preloads)
+    assert_equal([], path)
+  end
+end

data/test/lib/jat/plugins/cache/cache_test.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::Cache" do
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    to_h_mod = Module.new do
+      def to_h
+        "RES_#{object}"
+      end
+    end
+    new_class.include(to_h_mod)
+    new_class.plugin(:cache)
+    new_class
+  end
+
+  let(:context) { {cache: hash_cache} }
+  let(:hash_storage) { {} }
+  let(:hash_cache) do
+    hash_storage
+    lambda do |object, context, &block|
+      key = [object, context[:foo], context[:_format]].join(".").freeze
+      hash_storage[key] ||= block.call
+    end
+  end
+
+  describe "InstanceMethods" do
+    describe "#to_h" do
+      it "takes result from cache" do
+        result1 = jat_class.new("OBJECT", context).to_h
+        result2 = jat_class.new("OBJECT", context).to_h
+
+        assert_equal "RES_OBJECT", result1
+        assert_equal "RES_OBJECT", result2
+        assert_same result1, result2
+      end
+
+      it "does not take cached result when cache keys are different" do
+        result1 = jat_class.new("OBJECT", context).to_h
+        result2 = jat_class.new("OBJECT", context.merge(foo: :bazz)).to_h
+
+        assert_equal "RES_OBJECT", result1
+        assert_equal "RES_OBJECT", result2
+        refute_same result1, result2
+      end
+
+      it "does not saves cache when no context[:cache] provided" do
+        jat_class.new("OBJECT", {}).to_str
+
+        assert_equal [], hash_storage.keys
+      end
+    end
+
+    describe "#to_str" do
+      it "takes result from cache" do
+        result1 = jat_class.new("OBJECT", context).to_str
+        result2 = jat_class.new("OBJECT", context).to_str
+
+        assert_equal '"RES_OBJECT"', result1
+        assert_equal '"RES_OBJECT"', result2
+        assert_same result1, result2
+      end
+
+      it "does not take cached result when cache keys are different" do
+        result1 = jat_class.new("OBJECT", context).to_str
+        result2 = jat_class.new("OBJECT", context.merge(foo: :bazz)).to_str
+
+        assert_equal '"RES_OBJECT"', result1
+        assert_equal '"RES_OBJECT"', result2
+        refute_same result1, result2
+      end
+
+      it "does not saves cache for #to_h" do
+        context[:foo] = :bar
+        jat_class.new("OBJECT", context).to_str
+
+        assert_equal ["OBJECT.bar.to_str"], hash_storage.keys
+      end
+    end
+  end
+end

data/test/lib/jat/plugins/camel_lower/camel_lower_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::CamelLower" do
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.plugin(:camel_lower)
+    new_class
+  end
+
+  describe "Attribute" do
+    describe "#name" do
+      it "returns name in camel_lower case" do
+        attribute = jat_class.attribute(:foo)
+        assert :foo, attribute.name
+
+        attribute = jat_class.attribute(:foo_bar)
+        assert :fooBar, attribute.name
+
+        attribute = jat_class.attribute(:foo_bar_bazz)
+        assert :fooBarBazz, attribute.name
+      end
+    end
+  end
+
+  describe "Test responses with simple_api plugin" do
+    before { jat_class.plugin(:simple_api) }
+
+    it "returns attributes in camelLower case" do
+      jat_class.attribute(:foo_bar) { 1 }
+
+      response = jat_class.to_h(true)
+      assert_equal({fooBar: 1}, response)
+    end
+
+    it "accepts fields in camelLower format" do
+      jat_class.attribute(:foo_bar, exposed: false) { 1 }
+
+      response = jat_class.to_h(true, params: {fields: "fooBar"})
+      assert_equal({fooBar: 1}, response)
+    end
+  end
+
+  describe "Test responses with json_api plugin" do
+    before do
+      jat_class.plugin(:json_api)
+      jat_class.type :foo
+      jat_class.attribute(:id) { object }
+    end
+
+    it "returns attributes in camelLower case" do
+      jat_class.attribute(:foo_bar) { 1 }
+
+      assert_equal({fooBar: 1}, jat_class.to_h(true).dig(:data, :attributes))
+    end
+
+    it "accepts `fields` in camelLower format" do
+      jat_class.attribute(:foo_bar, exposed: false) { 1 }
+
+      response = jat_class.to_h(true, params: {fields: {foo: "fooBar"}})
+      assert_equal({fooBar: 1}, response.dig(:data, :attributes))
+    end
+
+    it "accepts `include` in camelLower format" do
+      new_serializer = Class.new(Jat)
+      new_serializer.plugin(:json_api)
+      new_serializer.type :new
+      new_serializer.attribute(:id) { object }
+
+      jat_class.relationship(:foo_bar, serializer: new_serializer) { 1 }
+
+      response = jat_class.to_h(true, params: {include: "fooBar"})
+      response_relationships = response.dig(:data, :relationships).keys
+      assert_includes(response_relationships, :fooBar)
+    end
+  end
+end

data/test/lib/jat/plugins/json_api/json_api_test.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi" do
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.plugin(plugin)
+    new_class.type :jat
+    new_class.attribute :id, key: :itself
+    new_class
+  end
+
+  let(:plugin) { Jat::Plugins.load_plugin(:json_api) }
+
+  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
+
+    it "registers Presenters constants" do
+      jat_class = Class.new(Jat)
+      Jat::Plugins.after_load(plugin, jat_class, activerecord: true)
+
+      assert_equal jat_class::JsonapiPresenter.jat_class, jat_class
+      assert_equal jat_class::LinksPresenter.jat_class, jat_class
+      assert_equal jat_class::DocumentLinksPresenter.jat_class, jat_class
+      assert_equal jat_class::RelationshipLinksPresenter.jat_class, jat_class
+      assert_equal jat_class::MetaPresenter.jat_class, jat_class
+      assert_equal jat_class::DocumentMetaPresenter.jat_class, jat_class
+      assert_equal jat_class::RelationshipMetaPresenter.jat_class, jat_class
+    end
+  end
+
+  describe "InstanceMethods" do
+    let(:jat) do
+      jat_class.new("JAT", {})
+    end
+
+    describe "#to_h" do
+      it "returns response in json-api format" do
+        expected_result = {data: {type: :jat, id: "JAT"}}
+        assert_equal expected_result, jat.to_h
+      end
+    end
+
+    describe "#traversal_map" do
+      it "returns memorized traversal_map object" do
+        assert_equal jat.traversal_map.class, Jat::Plugins::JsonApi::TraversalMap
+        assert_same jat.traversal_map, jat.traversal_map
+      end
+    end
+  end
+
+  describe "ClassMethods" do
+    describe ".relationship" do
+      it "adds new attribute with required serializer" do
+        jat_class.relationship(:foo, serializer: jat_class, exposed: true) { "block" }
+
+        atribute = jat_class.attributes[:foo]
+        assert_equal jat_class, atribute.serializer
+        assert_equal true, atribute.exposed?
+        assert_equal "block", jat_class::Presenter.new(nil, nil).foo
+      end
+    end
+
+    describe ".inherited" do
+      it "inherits type" do
+        child = Class.new(jat_class)
+        assert_equal :jat, child.type
+      end
+
+      it "inherits `jsonapi` data" do
+        jat_class.jsonapi(:version) { "1.0" }
+
+        child = Class.new(jat_class)
+        assert_equal("1.0", child.jsonapi_data[:version].call)
+      end
+
+      it "inherits `object_links`, `relationship_links`, `document_links`" do
+        jat_class.object_link(:self) { "/articles/1" }
+        jat_class.relationship_link(:related) { "/articles/2" }
+        jat_class.document_link(:last) { "/articles/3" }
+        child = Class.new(jat_class)
+
+        assert_equal("/articles/1", child.object_links[:self].call)
+        assert_equal("/articles/2", child.relationship_links[:related].call)
+        assert_equal("/articles/3", child.document_links[:last].call)
+      end
+
+      it "does not change parents links when children links are changed" do
+        jat_class.object_link(:self) { "/articles/1" }
+        jat_class.relationship_link(:related) { "/articles/2" }
+        jat_class.document_link(:last) { "/articles/3" }
+
+        child = Class.new(jat_class)
+        child.object_links.delete(:self)
+        child.relationship_links.delete(:related)
+        child.document_links.delete(:last)
+
+        assert_equal("/articles/1", jat_class.object_links[:self].call)
+        assert_equal("/articles/2", jat_class.relationship_links[:related].call)
+        assert_equal("/articles/3", jat_class.document_links[:last].call)
+      end
+
+      it "inherits `object_meta`, `relationship_meta`, `document_meta`" do
+        jat_class.object_meta(:self) { "foo/1" }
+        jat_class.relationship_meta(:related) { "foo/2" }
+        jat_class.document_meta(:last) { "foo/3" }
+        child = Class.new(jat_class)
+
+        assert_equal("foo/1", child.added_object_meta[:self].call)
+        assert_equal("foo/2", child.added_relationship_meta[:related].call)
+        assert_equal("foo/3", child.added_document_meta[:last].call)
+      end
+
+      it "does not change parents meta when children meta changed" do
+        jat_class.object_meta(:self) { "foo/1" }
+        jat_class.relationship_meta(:related) { "foo/2" }
+        jat_class.document_meta(:last) { "foo/3" }
+
+        child = Class.new(jat_class)
+        child.added_object_meta.delete(:self)
+        child.added_relationship_meta.delete(:related)
+        child.added_document_meta.delete(:last)
+
+        assert_equal("foo/1", jat_class.added_object_meta[:self].call)
+        assert_equal("foo/2", jat_class.added_relationship_meta[:related].call)
+        assert_equal("foo/3", jat_class.added_document_meta[:last].call)
+      end
+    end
+
+    describe ".type" do
+      it "does not allows to ask for type before type is defined" do
+        new_class = Class.new(Jat) { plugin(:json_api) }
+
+        error = assert_raises(Jat::Error) { new_class.type }
+        assert_equal "#{new_class} has no defined type", error.message
+      end
+
+      it "saves and returns current type" do
+        assert_equal :jat, jat_class.type
+      end
+
+      it "symbolizes type" do
+        jat_class.type "users"
+        assert_equal :users, jat_class.type
+      end
+    end
+  end
+end

data/test/lib/jat/plugins/json_api/lib/construct_traversal_map_test.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::ConstructTraversalMap" do
+  before { Jat::Plugins.load_plugin(:json_api) }
+
+  let(:described_class) { Jat::Plugins::JsonApi::ConstructTraversalMap }
+  let(:base_class) { Class.new(Jat) { plugin :json_api } }
+
+  let(:a) do
+    ser = Class.new(base_class)
+    ser.type :a
+
+    ser.attribute :a1
+    ser.attribute :a2
+    ser.attribute :a3, exposed: false
+
+    ser.relationship :b, serializer: b
+    ser.relationship :c, serializer: c
+    ser.relationship :d, serializer: d, exposed: true
+    ser
+  end
+
+  let(:b) do
+    ser = Class.new(base_class)
+    ser.type :b
+    ser.attribute :b1
+    ser.attribute :b2
+    ser.attribute :b3, exposed: false
+    ser
+  end
+
+  let(:c) do
+    ser = Class.new(base_class)
+    ser.type :c
+    ser.attribute :c1
+    ser.attribute :c2
+    ser.attribute :c3, exposed: false
+    ser
+  end
+
+  let(:d) do
+    ser = Class.new(base_class)
+    ser.type :d
+    ser.attribute :d1
+    ser.attribute :d2
+    ser.attribute :d3, exposed: false
+    ser
+  end
+
+  it "returns all attributes" do
+    result = described_class.new(a, :all).to_h
+    expected_result = {
+      a: {serializer: a, attributes: %i[a1 a2 a3], relationships: %i[b c d]},
+      b: {serializer: b, attributes: %i[b1 b2 b3], relationships: []},
+      c: {serializer: c, attributes: %i[c1 c2 c3], relationships: []},
+      d: {serializer: d, attributes: %i[d1 d2 d3], relationships: []}
+    }
+
+    assert_equal expected_result, result
+  end
+
+  it "returns exposed attributes" do
+    result = described_class.new(a, :exposed).to_h
+    expected_result = {
+      a: {serializer: a, attributes: %i[a1 a2], relationships: %i[d]},
+      d: {serializer: d, attributes: %i[d1 d2], relationships: []}
+    }
+
+    assert_equal expected_result, result
+  end
+
+  it "returns only manually exposed per-type attributes or exposed by default when no manual type provided" do
+    exposed = {
+      a: %i[a2 a3 c d],
+      c: %i[c2 c3],
+      d: %i[d2 d3]
+    }
+    result = described_class.new(a, :manual, manually_exposed: exposed).to_h
+    expected_result = {
+      a: {serializer: a, attributes: %i[a2 a3], relationships: %i[c d]},
+      c: {serializer: c, attributes: %i[c2 c3], relationships: []},
+      d: {serializer: d, attributes: %i[d2 d3], relationships: []}
+    }
+
+    assert_equal expected_result, result
+  end
+
+  it "returns manually exposed per-type attributes or exposed by default when no manual type provided" do
+    exposed = {
+      a: %i[a2 a3 b c],
+      c: %i[c2 c3]
+    }
+    result = described_class.new(a, :manual, manually_exposed: exposed).to_h
+    expected_result = {
+      a: {serializer: a, attributes: %i[a2 a3], relationships: %i[b c]},
+      b: {serializer: b, attributes: %i[b1 b2], relationships: []},
+      c: {serializer: c, attributes: %i[c2 c3], relationships: []}
+    }
+
+    assert_equal expected_result, result
+  end
+
+  it "returns combined auto-exposed and manualy exposed attributes" do
+    exposed = {
+      a: %i[c],
+      c: %i[c3]
+    }
+    result = described_class.new(a, :exposed, manually_exposed: exposed).to_h
+    expected_result = {
+      a: {serializer: a, attributes: %i[a1 a2], relationships: %i[c d]},
+      c: {serializer: c, attributes: %i[c1 c2 c3], relationships: []},
+      d: {serializer: d, attributes: %i[d1 d2], relationships: []}
+    }
+
+    assert_equal expected_result, result
+  end
+end

data/test/lib/jat/plugins/json_api/lib/map_test.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::Map" do
+  subject { Jat::Plugins::JsonApi::Map.call(jat) }
+
+  let(:jat_class) do
+    Class.new(Jat) do
+      plugin :json_api
+      type :jat
+    end
+  end
+  let(:jat) { jat_class.new(nil, params: {fields: param_fields, include: param_includes}) }
+
+  let(:default_map) { {a: :a1, b: :b1, c: :c1} }
+  let(:includes_map) { {b: :b2, c: :c2} }
+  let(:fields_map) { {c: :c3} }
+
+  before do
+    jat.traversal_map.expects(:exposed).returns(default_map)
+  end
+
+  describe "when no params given" do
+    let(:param_includes) { nil }
+    let(:param_fields) { nil }
+
+    it "returns map of exposed by default fields" do
+      assert_equal default_map, subject
+    end
+  end
+
+  describe "when fields given" do
+    let(:param_includes) { nil }
+    let(:param_fields) { "FIELDS" }
+
+    before do
+      constructor = Jat::Plugins::JsonApi::ConstructTraversalMap.allocate
+      constructor.expects(:to_h).returns(fields_map)
+
+      Jat::Plugins::JsonApi::Params::Fields
+        .expects(:call)
+        .with(jat, "FIELDS")
+        .returns("PARSED_FIELDS")
+
+      Jat::Plugins::JsonApi::ConstructTraversalMap
+        .expects(:new)
+        .with(jat_class, :manual, manually_exposed: "PARSED_FIELDS")
+        .returns(constructor)
+    end
+
+    it "constructs map with default and provided fields" do
+      assert_equal({a: :a1, b: :b1, c: :c3}, subject)
+    end
+  end
+
+  describe "when includes given" do
+    let(:param_includes) { "INCLUDES" }
+    let(:param_fields) { nil }
+
+    before do
+      constructor = Jat::Plugins::JsonApi::ConstructTraversalMap.allocate
+      constructor.expects(:to_h).returns(includes_map)
+
+      Jat::Plugins::JsonApi::Params::Include
+        .expects(:call)
+        .with(jat, "INCLUDES")
+        .returns("PARSED_INCLUDES")
+
+      Jat::Plugins::JsonApi::ConstructTraversalMap
+        .expects(:new)
+        .with(jat_class, :exposed, manually_exposed: "PARSED_INCLUDES")
+        .returns(constructor)
+    end
+
+    it "constructs map with default and included fields" do
+      assert_equal({a: :a1, b: :b2, c: :c2}, subject)
+    end
+  end
+
+  describe "when fields and includes given" do
+    let(:param_fields) { "FIELDS" }
+    let(:param_includes) { "INCLUDES" }
+
+    before do
+      constructor1 = Jat::Plugins::JsonApi::ConstructTraversalMap.allocate
+      constructor1.expects(:to_h).returns(fields_map)
+
+      Jat::Plugins::JsonApi::Params::Fields
+        .expects(:call)
+        .with(jat, "FIELDS")
+        .returns("PARSED_FIELDS")
+
+      Jat::Plugins::JsonApi::ConstructTraversalMap
+        .expects(:new)
+        .with(jat_class, :manual, manually_exposed: "PARSED_FIELDS")
+        .returns(constructor1)
+
+      constructor2 = Jat::Plugins::JsonApi::ConstructTraversalMap.allocate
+      constructor2.expects(:to_h).returns(includes_map)
+
+      Jat::Plugins::JsonApi::Params::Include
+        .expects(:call)
+        .with(jat, "INCLUDES")
+        .returns("PARSED_INCLUDES")
+
+      Jat::Plugins::JsonApi::ConstructTraversalMap
+        .expects(:new)
+        .with(jat_class, :exposed, manually_exposed: "PARSED_INCLUDES")
+        .returns(constructor2)
+    end
+
+    it "constructs map with using everything: defaults, includes, fields" do
+      assert_equal({a: :a1, b: :b2, c: :c3}, subject)
+    end
+  end
+end

data/test/lib/jat/plugins/json_api/lib/params/fields/parse_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::Params::Fields::Parse" do
+  before { Jat::Plugins.load_plugin(:json_api) }
+
+  let(:described_class) { Jat::Plugins::JsonApi::Params::Fields::Parse }
+
+  it "returns empty hash when param not provided" do
+    result = described_class.call(nil)
+    assert_equal({}, result)
+  end
+
+  it "returns hash with parsed keys" do
+    result = described_class.call(a: "a1,a2", b: "b1")
+    assert_equal({a: %i[a1 a2], b: %i[b1]}, result)
+  end
+
+  it "symbolizes types" do
+    result = described_class.call("a" => "a1,a2", "b" => "b1")
+    assert_equal({a: %i[a1 a2], b: %i[b1]}, result)
+  end
+end

data/test/lib/jat/plugins/json_api/lib/params/fields/validate_test.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::Params::Fields::Validate" do
+  before { Jat::Plugins.load_plugin(:json_api) }
+
+  let(:described_class) { Jat::Plugins::JsonApi::Params::Fields::Validate }
+  let(:base_class) { Class.new(Jat) { plugin :json_api } }
+  let(:a_serializer) { Class.new(base_class) }
+  let(:b_serializer) { Class.new(base_class) }
+
+  before do
+    ser = a_serializer
+    ser.type :a
+    ser.attribute :a1
+    ser.relationship :a2, serializer: b_serializer
+
+    ser = b_serializer
+    ser.type :b
+    ser.attribute :b1
+    ser.relationship :b2, serializer: a_serializer
+  end
+
+  it "does not raises when serializer has all requested keys" do
+    assert described_class.call(a_serializer.allocate, a: %i[a1 a2], b: %i[b1 b2])
+  end
+
+  it "does not raises when requested only fields for nested serializer" do
+    assert described_class.call(a_serializer.allocate, b: %i[b1 b2])
+  end
+
+  it "raises error when some type can not be in response" do
+    error = assert_raises(Jat::Error) { described_class.call(a_serializer.allocate, a: %i[a1 a2], foo: %i[b1 b2]) }
+    assert_equal "#{a_serializer} and its children have no requested type `foo`", error.message
+  end
+
+  it "raises error when some key is not present in main serializer" do
+    error = assert_raises(Jat::Error) { described_class.call(a_serializer.allocate, a: %i[b1]) }
+    assert_equal "#{a_serializer} has no requested attribute or relationship `b1`", error.message
+  end
+
+  it "raises error when some key is not present in nested serializer" do
+    error = assert_raises(Jat::Error) { described_class.call(a_serializer.allocate, a: %i[a1], b: %i[a1]) }
+    assert_equal "#{b_serializer} has no requested attribute or relationship `a1`", error.message
+  end
+end

data/test/lib/jat/plugins/json_api/lib/params/fields_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::Params::Fields" do
+  before { Jat::Plugins.load_plugin(:json_api) }
+
+  let(:jat_class) do
+    Class.new(Jat) do
+      plugin :json_api
+      type :a
+
+      attribute :a1
+      attribute :a2
+      attribute :a3
+    end
+  end
+
+  let(:described_class) { Jat::Plugins::JsonApi::Params::Fields }
+
+  it "returns empty hash when parameters not provided" do
+    result = described_class.call(jat_class.allocate, nil)
+
+    assert_equal({}, result)
+  end
+
+  it "returns parsed attributes" do
+    result = described_class.call(jat_class.allocate, a: "a1,a2")
+
+    assert_equal({a: %i[a1 a2]}, result)
+  end
+
+  it "validates provided attributes" do
+    error = assert_raises(Jat::Error) { described_class.call(jat_class.allocate, a: "a1,a2,a3,a4") }
+    assert_match(/a4/, error.message)
+  end
+end