jat 0.0.1 → 0.0.7

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::Preloads::FormatUserPreloads" do
+  before { Jat::Plugins.find_plugin(:_preloads) }
+
+  let(:format) { Jat::Plugins::Preloads::FormatUserPreloads }
+
+  it "transforms nil to empty hash" do
+    preloads = nil
+    assert_equal ({}), format.to_hash(preloads)
+  end
+
+  it "transforms false to empty hash" do
+    preloads = false
+    assert_equal({}, format.to_hash(preloads))
+  end
+
+  it "transforms Symbol" do
+    preloads = :foo
+    assert_equal({foo: {}}, format.to_hash(preloads))
+  end
+
+  it "transforms String" do
+    preloads = "foo"
+    assert_equal({foo: {}}, format.to_hash(preloads))
+  end
+
+  it "transforms Hash" do
+    preloads = {foo: :bar}
+    assert_equal({foo: {bar: {}}}, format.to_hash(preloads))
+  end
+
+  it "transforms Array" do
+    preloads = %i[foo bar]
+    assert_equal({foo: {}, bar: {}}, format.to_hash(preloads))
+  end
+
+  it "transforms nested hashes and arrays" do
+    preloads = [:foo, {"bar" => "bazz"}, ["bazz"]]
+    assert_equal({foo: {}, bar: {bazz: {}}, bazz: {}}, format.to_hash(preloads))
+
+    preloads = {"bar" => "bazz", :foo => [:bar, "bazz"]}
+    assert_equal({bar: {bazz: {}}, foo: {bar: {}, bazz: {}}}, format.to_hash(preloads))
+  end
+end

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.find_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(object)
+        "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(context).to_h("OBJECT")
+        result2 = jat_class.new(context).to_h("OBJECT")
+
+        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(context).to_h("OBJECT")
+        result2 = jat_class.new(context.merge(foo: :bazz)).to_h("OBJECT")
+
+        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({}).to_str("OBJECT")
+
+        assert_equal [], hash_storage.keys
+      end
+    end
+
+    describe "#to_str" do
+      it "takes result from cache" do
+        result1 = jat_class.new(context).to_str("OBJECT")
+        result2 = jat_class.new(context).to_str("OBJECT")
+
+        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(context).to_str("OBJECT")
+        result2 = jat_class.new(context.merge(foo: :bazz)).to_str("OBJECT")
+
+        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(context).to_str("OBJECT")
+
+        assert_equal ["OBJECT.bar.to_str"], hash_storage.keys
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+# 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.id key: :itself
+    new_class
+  end
+
+  let(:plugin) { Jat::Plugins.find_plugin(:json_api) }
+
+  describe ".before_load" do
+    it "checks some response plugin was already loaded" do
+      jat_class = Class.new(Jat)
+      jat_class.config[:response_plugin_loaded] = :simple_api
+      error = assert_raises(Jat::Error) { jat_class.plugin(:json_api) }
+      assert_equal "Response plugin `simple_api` was already loaded before", error.message
+    end
+  end
+
+  describe ".after_load" do
+    it "adds config variable with name of response plugin that was loaded" do
+      jat_class = Class.new(Jat)
+      jat_class.plugin(:json_api)
+
+      assert_equal(:json_api, jat_class.config[:response_plugin_loaded])
+    end
+  end
+
+  describe "InstanceMethods" do
+    let(:jat) do
+      jat_class.new
+    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("JAT")
+      end
+    end
+
+    describe "#map" do
+      it "returns map for provided context" do
+        jat_class::Map.expects(:call).with("CONTEXT").returns "MAP"
+        assert_equal "MAP", jat_class.map("CONTEXT")
+      end
+    end
+
+    describe "#map_full" do
+      it "returns memorized map with all fields exposed" do
+        jat_class::Map.expects(:call).with(exposed: :all).returns "MAP"
+        assert_equal "MAP", jat_class.map_full
+        assert_same jat_class.map_full, jat_class.map_full
+      end
+    end
+
+    describe "#map_exposed" do
+      it "returns memorized map with exposed by default fields" do
+        jat_class::Map.expects(:call).with(exposed: :default).returns "MAP"
+        assert_equal "MAP", jat_class.map_exposed
+        assert_same jat_class.map_exposed, jat_class.map_exposed
+      end
+    end
+  end
+
+  describe "ClassMethods" do
+    describe ".id" do
+      it "adds new `:id`" do
+        jat_class.id(key: :uuid)
+        assert_equal jat_class.get_id.params, {name: :id, opts: {key: :uuid}, block: nil}
+      end
+    end
+
+    describe ".inherited" do
+      it "inherits type" do
+        child = Class.new(jat_class)
+        assert_equal :jat, child.get_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].value(nil, nil))
+      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].value(nil, nil))
+        assert_equal("/articles/2", child.relationship_links[:related].value(nil, nil))
+        assert_equal("/articles/3", child.document_links[:last].value(nil, nil))
+      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].value(nil, nil))
+        assert_equal("/articles/2", jat_class.relationship_links[:related].value(nil, nil))
+        assert_equal("/articles/3", jat_class.document_links[:last].value(nil, nil))
+      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].value(nil, nil))
+        assert_equal("foo/2", child.added_relationship_meta[:related].value(nil, nil))
+        assert_equal("foo/3", child.added_document_meta[:last].value(nil, nil))
+      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].value(nil, nil))
+        assert_equal("foo/2", jat_class.added_relationship_meta[:related].value(nil, nil))
+        assert_equal("foo/3", jat_class.added_document_meta[:last].value(nil, nil))
+      end
+    end
+
+    describe ".type, .get_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.get_type }
+        assert_equal "#{new_class} has no defined type", error.message
+      end
+
+      it "saves and returns current type" do
+        assert_equal :jat, jat_class.get_type
+      end
+
+      it "symbolizes type" do
+        jat_class.type "users"
+        assert_equal :users, jat_class.get_type
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::FieldsParamParser" do
+  before { Jat::Plugins.find_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_class::FieldsParamParser }
+
+  it "returns empty hash when parameters not provided" do
+    result = described_class.parse(nil)
+
+    assert_equal({}, result)
+  end
+
+  it "returns parsed attributes" do
+    result = described_class.parse(a: "a1,a2")
+
+    assert_equal({a: %i[a1 a2]}, result)
+  end
+
+  it "validates provided attributes" do
+    jat_class.plugin :json_api_validate_params
+    error = assert_raises(Jat::Error) { described_class.parse(a: "a1,a2,a3,a4") }
+    assert_match(/a4/, error.message)
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::Params::Include" do
+  before { Jat::Plugins.find_plugin(:json_api) }
+
+  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.relationship :a3, serializer: b_serializer
+    ser.relationship :a4, serializer: b_serializer
+    ser.relationship :a5, serializer: b_serializer
+    ser.relationship :a6, serializer: b_serializer
+
+    ser = b_serializer
+    ser.type :b
+    ser.attribute :b1
+    ser.relationship :b2, serializer: a_serializer
+    ser.relationship :b3, serializer: a_serializer
+    ser.relationship :b4, serializer: a_serializer
+  end
+
+  let(:described_class) { a_serializer::IncludeParamParser }
+
+  it "returns empty hash when param not provided" do
+    result = described_class.parse(nil)
+    assert_equal({}, result)
+  end
+
+  it "returns typed keys" do
+    result = described_class.parse("a2.b2,a2.b3,a3.b2.a5,a4")
+    assert_equal({a: %i[a2 a3 a5 a4], b: %i[b2 b3]}, result)
+  end
+end

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

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::Map" do
+  before { Jat::Plugins.find_plugin(:json_api) }
+
+  let(:described_class) { a::Map }
+  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, exposed: true
+    ser.relationship :c, serializer: c
+    ser.relationship :d, serializer: d
+    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.relationship :c, serializer: c
+    ser.relationship :d, serializer: d
+    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
+
+  describe "with default :exposed option" do
+    it "returns exposed by default attributes" do
+      result = described_class.call(exposed: :default)
+      expected_result = {
+        a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b]},
+        b: {serializer: b, attributes: %i[b1 b2], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "returns exposed by default attributes when no :exposed param provided" do
+      result = described_class.call({})
+      expected_result = {
+        a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b]},
+        b: {serializer: b, attributes: %i[b1 b2], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "returns additionally included fields specified in :includes option" do
+      includes = "c,b.d"
+      result = described_class.call(include: includes)
+      expected_result = {
+        a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b c]},
+        b: {serializer: b, attributes: %i[b1 b2], relationships: %i[d]},
+        c: {serializer: c, attributes: %i[c1 c2], relationships: %i[]},
+        d: {serializer: d, attributes: %i[d1 d2], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "returns fields specified in :fields option (only specified fields for specified type)" do
+      fields = {b: "b1,d"}
+      result = described_class.call(fields: fields)
+      expected_result = {
+        a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b]},
+        b: {serializer: b, attributes: %i[b1], relationships: %i[d]},
+        d: {serializer: d, attributes: %i[d1 d2], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "returns fields specified in :includes and :fields options" do
+      includes = "c"
+      fields = {c: "c1"}
+      result = described_class.call(include: includes, fields: fields)
+      expected_result = {
+        a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b c]},
+        b: {serializer: b, attributes: %i[b1 b2], relationships: %i[]},
+        c: {serializer: c, attributes: %i[c1], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+  end
+
+  describe "with exposed: :none option" do
+    it "returns no attributes" do
+      result = described_class.call(exposed: :none)
+      expected_result = {
+        a: {serializer: a, attributes: %i[], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "returns additionally included fields specified in :includes option" do
+      includes = "b.c"
+      result = described_class.call(exposed: :none, include: includes)
+      expected_result = {
+        a: {serializer: a, attributes: %i[], relationships: %i[b]},
+        b: {serializer: b, attributes: %i[], relationships: %i[c]},
+        c: {serializer: c, attributes: %i[], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "returns fields specified in :fields option (only specified fields for specified type)" do
+      fields = {a: "a1,b", b: "b1,d"}
+      result = described_class.call(exposed: :none, fields: fields)
+      expected_result = {
+        a: {serializer: a, attributes: %i[a1], relationships: %i[b]},
+        b: {serializer: b, attributes: %i[b1], relationships: %i[d]},
+        d: {serializer: d, attributes: %i[], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "returns fields specified in :includes and :fields options" do
+      includes = "c"
+      fields = {c: "c1"}
+      result = described_class.call(exposed: :none, include: includes, fields: fields)
+      expected_result = {
+        a: {serializer: a, attributes: %i[], relationships: %i[c]},
+        c: {serializer: c, attributes: %i[c1], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+  end
+
+  describe "with exposed: :all option" do
+    it "returns all attributes" do
+      result = described_class.call(exposed: :all)
+      expected_result = {
+        a: {serializer: a, attributes: %i[a1 a2 a3], relationships: %i[b c d]},
+        b: {serializer: b, attributes: %i[b1 b2 b3], relationships: %i[c d]},
+        c: {serializer: c, attributes: %i[c1 c2 c3], relationships: %i[]},
+        d: {serializer: d, attributes: %i[d1 d2 d3], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "returns only specified fields for specified fields types" do
+      fields = {b: "b1", c: "c2"}
+      result = described_class.call(exposed: :all, fields: fields)
+      expected_result = {
+        a: {serializer: a, attributes: %i[a1 a2 a3], relationships: %i[b c d]},
+        b: {serializer: b, attributes: %i[b1], relationships: %i[]},
+        c: {serializer: c, attributes: %i[c2], relationships: %i[]},
+        d: {serializer: d, attributes: %i[d1 d2 d3], relationships: %i[]}
+      }
+
+      assert_equal expected_result, result
+    end
+  end
+end