jat 0.0.1 → 0.0.7

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

@@ -0,0 +1,489 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::Response" do
+  let(:base_class) { Class.new(Jat) { plugin :json_api } }
+
+  it "returns empty hash when nothing to serialize" do
+    empty_serializer = Class.new(base_class) { type :foo }
+
+    assert_equal({}, empty_serializer.to_h(nil))
+  end
+
+  it "returns correct structure with data" do
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |_| "STRING" }
+    end
+
+    assert_equal({data: {type: :str, id: "STRING"}}, str_serializer.to_h("STRING"))
+  end
+
+  it "returns correct structure with array data" do
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |obj| obj }
+    end
+
+    assert_equal(
+      {data: [{type: :str, id: "1"}, {type: :str, id: "2"}]},
+      str_serializer.to_h(%w[1 2], many: true)
+    )
+  end
+
+  it "returns correct structure with data with attributes" do
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |obj| obj[0] }
+      attribute :length
+    end
+
+    assert_equal(
+      {data: {type: :str, id: "S", attributes: {length: 6}}},
+      str_serializer.to_h("STRING")
+    )
+  end
+
+  it "returns correct structure with has-one relationship" do
+    int_serializer = Class.new(base_class) do
+      type "int"
+      id { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |obj| obj[0] }
+      relationship :length, serializer: int_serializer, exposed: true
+    end
+
+    assert_equal(
+      {
+        data: {
+          type: :str, id: "S",
+          relationships: {
+            length: {data: {type: :int, id: 6}}
+          }
+        },
+        included: [
+          {type: :int, 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
+      type "int"
+      id { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |obj| obj[0] }
+      relationship :length, serializer: int_serializer # relationships are not exposed by default
+    end
+
+    assert_equal({data: {type: :str, id: "S"}}, str_serializer.to_h("STRING"))
+  end
+
+  it "returns correct structure with empty has-one relationship" do
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |obj| obj[0] }
+      relationship(:length, serializer: self, exposed: true) { |_obj| nil }
+    end
+
+    assert_equal(
+      {
+        data: {
+          type: :str, id: "S",
+          relationships: {length: {data: 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
+      type "int"
+      id { |obj| obj }
+      attribute(:next) { |obj| obj + 1 }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |obj| obj[0] }
+      relationship :length, serializer: int_serializer, exposed: true
+    end
+
+    assert_equal(
+      {
+        data: {
+          type: :str, id: "S",
+          relationships: {
+            length: {data: {type: :int, id: 6}}
+          }
+        },
+        included: [
+          {type: :int, id: 6, attributes: {next: 7}}
+        ]
+      },
+      str_serializer.to_h("STRING")
+    )
+  end
+
+  it "returns correct structure with empty has-many relationship" do
+    chr_serializer = Class.new(base_class) do
+      type "chr"
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |_obj| "id" }
+      relationship :chars, serializer: chr_serializer, many: true, exposed: true
+    end
+
+    assert_equal(
+      {
+        data: {
+          type: :str, id: "id",
+          relationships: {chars: {data: []}}
+        }
+      },
+      str_serializer.to_h("")
+    )
+  end
+
+  it "returns correct structure with has-many relationship" do
+    chr_serializer = Class.new(base_class) do
+      type "chr"
+      id { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |obj| obj[0] }
+      relationship :chars, serializer: chr_serializer, many: true, exposed: true
+    end
+
+    assert_equal(
+      {
+        data: {
+          type: :str, id: "a",
+          relationships: {
+            chars: {data: [{type: :chr, id: "a"}, {type: :chr, id: "b"}]}
+          }
+        },
+        included: [
+          {type: :chr, id: "a"}, {type: :chr, id: "b"}
+        ]
+      },
+      str_serializer.to_h("ab")
+    )
+  end
+
+  it "returns correct structure with has-many relationship with attributes" do
+    chr_serializer = Class.new(base_class) do
+      type "chr"
+      id { |obj| obj }
+      attribute :next
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |obj| obj[0] }
+      relationship :chars, serializer: chr_serializer, many: true, exposed: true
+    end
+
+    assert_equal(
+      {
+        data: {
+          type: :str, id: "a",
+          relationships: {
+            chars: {data: [{type: :chr, id: "a"}, {type: :chr, id: "b"}]}
+          }
+        },
+        included: [
+          {type: :chr, id: "a", attributes: {next: "b"}},
+          {type: :chr, id: "b", attributes: {next: "c"}}
+        ]
+      },
+      str_serializer.to_h("ab")
+    )
+  end
+
+  it "accepts includes param" do
+    chr_serializer = Class.new(base_class) do
+      type "chr"
+      id { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |obj| obj[0] }
+      relationship :chars, serializer: chr_serializer, many: true, exposed: false
+    end
+
+    assert_equal(
+      {
+        data: {
+          type: :str, id: "a",
+          relationships: {
+            chars: {data: [{type: :chr, id: "a"}, {type: :chr, id: "b"}]}
+          }
+        },
+        included: [
+          {type: :chr, id: "a"}, {type: :chr, id: "b"}
+        ]
+      },
+      str_serializer.to_h("ab", include: "chars")
+    )
+  end
+
+  it "accepts sparse_fieldset" do
+    chr_serializer = Class.new(base_class) do
+      type "chr"
+      id { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      id { |obj| obj[0] }
+      relationship :chars, serializer: chr_serializer, many: true, exposed: false
+    end
+
+    assert_equal(
+      {
+        data: {
+          type: :str, id: "a",
+          relationships: {
+            chars: {data: [{type: :chr, id: "a"}, {type: :chr, id: "b"}]}
+          }
+        },
+        included: [
+          {type: :chr, id: "a"}, {type: :chr, id: "b"}
+        ]
+      },
+      str_serializer.to_h("ab", fields: {str: "chars"})
+    )
+  end
+
+  describe "json_api" do
+    let(:serializer) do
+      Class.new(base_class) do
+        type :foo
+        id { |obj| obj }
+      end
+    end
+
+    it "adds `jsonapi` fields defined in serializer" do
+      serializer.jsonapi(:version) { "1.2.3" }
+      serializer.jsonapi(:uid) { |obj, context| [obj, context[:time]] }
+
+      response = serializer.to_h("bar", time: "12:00")
+      jsonapi = response.dig(:jsonapi)
+      assert_equal({version: "1.2.3", uid: ["bar", "12:00"]}, jsonapi)
+    end
+
+    it "does not overwrite manually added data" do
+      serializer.jsonapi(:version) { "1.2.3" }
+      serializer.jsonapi(:foo) { :bar }
+
+      response = serializer.to_h("bar", jsonapi: {version: "3.2.1"})
+      jsonapi = response.dig(:jsonapi)
+      assert_equal({version: "3.2.1", foo: :bar}, jsonapi)
+    end
+
+    it "does not add jsonapi attributes with nil values" do
+      serializer.jsonapi(:foo) {}
+      serializer.jsonapi(:bar) { false }
+
+      response = serializer.to_h("bar")
+      jsonapi = response.dig(:jsonapi)
+      assert_equal({bar: false}, jsonapi)
+    end
+  end
+
+  describe "document_meta" do
+    let(:serializer) do
+      Class.new(base_class) do
+        type :foo
+        id { |obj| obj }
+      end
+    end
+
+    it "adds document meta defined in serializer" do
+      serializer.document_meta(:version) { "1.2.3" }
+      serializer.document_meta(:uid) { |obj, context| [obj, context[:time]] }
+
+      response = serializer.to_h("bar", time: "12:00")
+      meta = response.dig(:meta)
+      assert_equal({version: "1.2.3", uid: ["bar", "12:00"]}, meta)
+    end
+
+    it "does not overwrite manually added meta" do
+      serializer.document_meta(:version) { "1.2.3" }
+      serializer.document_meta(:foo) { :bar }
+
+      response = serializer.to_h("bar", meta: {version: "3.2.1"})
+      meta = response.dig(:meta)
+      assert_equal({version: "3.2.1", foo: :bar}, meta)
+    end
+
+    it "does not add meta with nil values" do
+      serializer.document_meta(:foo) {}
+      serializer.document_meta(:bar) { false }
+
+      response = serializer.to_h("bar")
+      meta = response.dig(:meta)
+      assert_equal({bar: false}, meta)
+    end
+  end
+
+  describe "resource meta" do
+    let(:serializer) do
+      Class.new(base_class) do
+        type :foo
+        id { |obj| obj }
+      end
+    end
+
+    it "adds meta defined in serializer" do
+      serializer.object_meta(:version) { "1.2.3" }
+      serializer.object_meta(:uid) { |obj, context| [obj, context[:time]] }
+
+      response = serializer.to_h("bar", time: "12:00")
+      meta = response.dig(:data, :meta)
+      assert_equal({version: "1.2.3", uid: ["bar", "12:00"]}, meta)
+    end
+
+    it "does not add meta with nil values" do
+      serializer.object_meta(:foo) {}
+      serializer.object_meta(:bar) { false }
+
+      response = serializer.to_h("bar")
+      meta = response.dig(:data, :meta)
+      assert_equal({bar: false}, meta)
+    end
+  end
+
+  describe "relationship meta" do
+    let(:bar_serializer) do
+      Class.new(base_class) do
+        type :bar
+        id { |obj| obj }
+      end
+    end
+
+    let(:foo_serializer) do
+      Class.new(base_class) do
+        type :foo
+        id { |obj| obj }
+      end
+    end
+
+    it "adds relationship meta defined in serializer" do
+      foo_serializer.relationship(:bar, serializer: -> { bar_serializer }, exposed: true) { "bar" }
+      bar_serializer.relationship_meta(:version) { "1.2.3" }
+      bar_serializer.relationship_meta(:uid) { |obj, context| [context[:parent_object], obj, context[:time]] }
+      bar_serializer.relationship_meta(:null) {}
+
+      response = foo_serializer.to_h("foo", time: "12:00")
+      meta = response.dig(:data, :relationships, :bar, :meta)
+      assert_equal({version: "1.2.3", uid: ["foo", "bar", "12:00"]}, meta)
+    end
+  end
+
+  describe "document_link" do
+    let(:serializer) do
+      Class.new(base_class) do
+        type :foo
+        id { |obj| obj }
+      end
+    end
+
+    it "adds document links defined in serializer" do
+      serializer.document_link(:self) { "/self" }
+      serializer.document_link(:related) { |obj| "/#{obj}/self" }
+
+      response = serializer.to_h("bar")
+      links = response.dig(:links)
+      assert_equal({self: "/self", related: "/bar/self"}, links)
+    end
+
+    it "does not overwrite manually added links" do
+      serializer.document_link(:self) { "/self" }
+      serializer.document_link(:related) { |obj| "/#{obj}/self" }
+
+      response = serializer.to_h("bar", links: {self: "/foo"})
+      links = response.dig(:links)
+      assert_equal({self: "/foo", related: "/bar/self"}, links)
+    end
+
+    it "does not add links with nil values" do
+      serializer.document_link(:foo) {}
+      serializer.document_link(:bar) { false }
+
+      response = serializer.to_h("bar")
+      links = response.dig(:links)
+      assert_equal({bar: false}, links)
+    end
+  end
+
+  describe "resource links" do
+    let(:serializer) do
+      Class.new(base_class) do
+        type :foo
+        id { |obj| obj }
+      end
+    end
+
+    it "adds links defined in serializer" do
+      serializer.object_link(:self) { "/self" }
+      serializer.object_link(:related) { |obj| "/#{obj}/self" }
+
+      response = serializer.to_h("bar", time: "12:00")
+      links = response.dig(:data, :links)
+      assert_equal({self: "/self", related: "/bar/self"}, links)
+    end
+
+    it "does not add links with nil values" do
+      serializer.object_link(:foo) {}
+      serializer.object_link(:bar) { false }
+
+      response = serializer.to_h("bar")
+      links = response.dig(:data, :links)
+      assert_equal({bar: false}, links)
+    end
+  end
+
+  describe "relationship links" do
+    let(:bar_serializer) do
+      Class.new(base_class) do
+        type :bar
+        id { |obj| obj }
+      end
+    end
+
+    let(:foo_serializer) do
+      Class.new(base_class) do
+        type :foo
+        id { |obj| obj }
+      end
+    end
+
+    it "adds relationship link defined in serializer" do
+      foo_serializer.relationship(:bar, serializer: -> { bar_serializer }, exposed: true) { "bar" }
+      bar_serializer.relationship_link(:self) { "/self" }
+      bar_serializer.relationship_link(:related) { |_obj, ctx| "/#{ctx[:parent_object]}/self" }
+      bar_serializer.relationship_link(:null) {}
+
+      response = foo_serializer.to_h("foo")
+      links = response.dig(:data, :relationships, :bar, :links)
+      assert_equal({self: "/self", related: "/foo/self"}, links)
+    end
+  end
+end

data/test/lib/jat/plugins/json_api_activerecord/json_api_activerecord_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApiActiverecord" do
+  before do
+    @plugin = Jat::Plugins.find_plugin(:json_api_activerecord)
+  end
+
+  it "checks json_api plugin loaded before" do
+    jat_class = Class.new(Jat)
+    error = assert_raises(Jat::Error) { jat_class.plugin @plugin }
+    assert_match(/json_api/, error.message)
+  end
+
+  it "loads other plugins" do
+    jat_class = Class.new(Jat)
+    jat_class.plugin :json_api
+    jat_class.plugin :json_api_activerecord
+
+    assert jat_class.plugin_used?(:json_api_preloads)
+    assert jat_class.plugin_used?(:_activerecord_preloads)
+  end
+end

data/test/lib/jat/plugins/json_api_camel_lower/json_api_camel_lower_test.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApiLowerCamelCase" do
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.plugin(:json_api)
+    new_class.plugin(:json_api_lower_camel_case)
+    new_class
+  end
+
+  before do
+    jat_class.type :foo
+    jat_class.id { |object| object }
+  end
+
+  it "returns attributes in lowerCamelCase 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 lowerCamelCase format" do
+    jat_class.attribute(:foo_bar, exposed: false) { 1 }
+
+    response = jat_class.to_h(true, fields: {foo: "fooBar"})
+    assert_equal({fooBar: 1}, response.dig(:data, :attributes))
+  end
+
+  it "accepts `include` in lowerCamelCase format" do
+    new_serializer = Class.new(Jat)
+    new_serializer.plugin(:json_api)
+    new_serializer.type :new
+    new_serializer.id { |object| object }
+
+    jat_class.relationship(:foo_bar, serializer: new_serializer) { 1 }
+
+    response = jat_class.to_h(true, include: "fooBar")
+    response_relationships = response.dig(:data, :relationships).keys
+    assert_includes(response_relationships, :fooBar)
+  end
+
+  it "returns document meta keys in lowerCamelCase format" do
+    jat_class.document_meta(:user_agent) { "Firefox" }
+
+    response = jat_class.to_h(nil)
+    assert_equal({meta: {userAgent: "Firefox"}}, response)
+  end
+
+  it "returns document jsonapi keys in lowerCamelCase format" do
+    jat_class.jsonapi(:user_agent) { "Firefox" }
+
+    response = jat_class.to_h(nil)
+    assert_equal({jsonapi: {userAgent: "Firefox"}}, response)
+  end
+
+  it "returns document links keys in lowerCamelCase format" do
+    jat_class.document_link(:user_agent) { "Firefox" }
+
+    response = jat_class.to_h(nil)
+    assert_equal({links: {userAgent: "Firefox"}}, response)
+  end
+
+  it "returns context meta keys in lowerCamelCase format" do
+    response = jat_class.to_h(nil, meta: {user_agent: "Chrome"})
+    assert_equal({meta: {userAgent: "Chrome"}}, response)
+  end
+
+  it "returns context jsonapi keys in lowerCamelCase format" do
+    response = jat_class.to_h(nil, jsonapi: {user_agent: "Chrome"})
+    assert_equal({jsonapi: {userAgent: "Chrome"}}, response)
+  end
+
+  it "returns context links keys in lowerCamelCase format" do
+    response = jat_class.to_h(nil, links: {user_agent: "Chrome"})
+    assert_equal({links: {userAgent: "Chrome"}}, response)
+  end
+end

data/test/lib/jat/plugins/json_api_maps_cache/json_api_maps_cache_test.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApiMapsCache" do
+  before do
+    @plugin = Jat::Plugins.find_plugin(:json_api_maps_cache)
+  end
+
+  it "checks json_api plugin loaded before" do
+    jat_class = Class.new(Jat)
+    error = assert_raises(Jat::Error) { jat_class.plugin @plugin }
+    assert_match(/json_api/, error.message)
+  end
+
+  it "adds config variable how many maps to store per serializer" do
+    jat_class = Class.new(Jat)
+
+    @plugin.after_load(jat_class)
+    assert_equal(100, jat_class.config[:cached_maps_count]) # default 100
+
+    @plugin.after_load(jat_class, cached_maps_count: 10) # change value via opts
+    assert_equal(10, jat_class.config[:cached_maps_count])
+  end
+
+  describe "Test maps responses" do
+    let(:jat_class) do
+      Class.new(Jat) do
+        plugin(:json_api)
+        plugin(:json_api_maps_cache)
+
+        type :foo
+
+        attribute(:attr1)
+        attribute(:attr2)
+
+        relationship(:rel1, serializer: self)
+        relationship(:rel2, serializer: self)
+      end
+    end
+
+    it "returns same maps when requested with same params" do
+      full_map1 = jat_class::Map.call(exposed: :all)
+      full_map2 = jat_class::Map.call(exposed: :all)
+
+      exposed_map1 = jat_class::Map.call(exposed: :default)
+      exposed_map2 = jat_class::Map.call(exposed: :default)
+
+      current_map1 = jat_class::Map.call(include: "rel2", fields: {foo: "attr1,rel1"})
+      current_map2 = jat_class::Map.call(include: "rel2", fields: {foo: "attr1,rel1"})
+
+      assert_same(full_map1, full_map2)
+      assert_same(exposed_map1, exposed_map2)
+      assert_same(current_map1, current_map2)
+
+      # check different maps are not same
+
+      # should not match, include is not same
+      current_map3 = jat_class::Map.call(include: "rel1", fields: {foo: "attr1,rel1"})
+      # should not match, fields are not same
+      current_map4 = jat_class::Map.call(include: "rel2", fields: {foo: "attr1,rel2"})
+
+      assert !current_map1.equal?(current_map3)
+      assert !current_map1.equal?(current_map4)
+      assert !current_map3.equal?(current_map4)
+    end
+
+    it "stores different maps keys" do
+      # key 1
+      jat_class::Map.call(exposed: :all)
+      jat_class::Map.call(exposed: :all)
+
+      # key 2
+      jat_class::Map.call(exposed: :default)
+      jat_class::Map.call(exposed: :default)
+
+      # key 3
+      jat_class::Map.call(include: "rel2", fields: {foo: "attr1,rel1"})
+      jat_class::Map.call(include: "rel2", fields: {foo: "attr1,rel1"})
+
+      # key 4
+      jat_class::Map.call(include: "rel1", fields: {foo: "attr1,rel1"})
+
+      # key 5
+      jat_class::Map.call(include: "rel2", fields: {foo: "attr1,rel2"})
+
+      assert_equal 5, jat_class::Map.maps_cache.keys.count
+    end
+
+    it "clears old results when there are too many cache keys" do
+      jat_class.config[:cached_maps_count] = 1
+
+      full_map1 = jat_class::Map.call(exposed: :all)
+      full_map2 = jat_class::Map.call(exposed: :all)
+
+      # ensure maps refer to same object
+      assert_same(full_map1, full_map2)
+
+      # replace single possible cache key with another `exposed` map
+      jat_class::Map.call(exposed: :default)
+
+      # calculate full map again, it should not match
+      full_map3 = jat_class::Map.call(exposed: :all)
+      assert !full_map1.equal?(full_map3)
+    end
+  end
+end