jat 0.0.1 → 0.0.3

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"
+      attribute(: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"
+      attribute(: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"
+      attribute(: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"
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      attribute(: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"
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      attribute(: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"
+      attribute(: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"
+      attribute(:id) { |obj| obj }
+      attribute(:next) { |obj| obj + 1 }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      attribute(: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"
+      attribute(: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"
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      attribute(: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"
+      attribute(:id) { |obj| obj }
+      attribute :next
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      attribute(: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"
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      attribute(: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", params: {include: "chars"})
+    )
+  end
+
+  it "accepts sparse_fieldset" do
+    chr_serializer = Class.new(base_class) do
+      type "chr"
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      type "str"
+      attribute(: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", params: {fields: {str: "chars"}})
+    )
+  end
+
+  describe "json_api" do
+    let(:serializer) do
+      Class.new(base_class) do
+        type :foo
+        attribute(: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
+        attribute(: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
+        attribute(: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
+        attribute(:id) { |obj| obj }
+      end
+    end
+
+    let(:foo_serializer) do
+      Class.new(base_class) do
+        type :foo
+        attribute(: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) { |parent, obj, context| [parent, 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
+        attribute(: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
+        attribute(: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
+        attribute(:id) { |obj| obj }
+      end
+    end
+
+    let(:foo_serializer) do
+      Class.new(base_class) do
+        type :foo
+        attribute(: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) { |parent_obj| "/#{parent_obj}/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/lib/traversal_map_test.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::TraversalMap" do
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.attribute :foo, exposed: true
+    new_class.attribute :bar, exposed: false
+    new_class
+  end
+
+  let(:jat) do
+    jat_class.new("JAT", params: {fields: {jat: "bar"}})
+  end
+
+  before do
+    jat_class.plugin :json_api
+    jat_class.type :jat
+  end
+
+  describe "#jat" do
+    it "returns initialization value" do
+      map = Jat::Plugins::JsonApi::TraversalMap.new(jat)
+      assert_same jat, map.jat
+    end
+  end
+
+  describe "#exposed" do
+    it "returns memorized exposed map" do
+      map = Jat::Plugins::JsonApi::TraversalMap.new(jat)
+      expected_map_hash = Jat::Plugins::JsonApi::ConstructTraversalMap.new(jat_class, :exposed).to_h
+
+      assert_equal expected_map_hash, map.exposed
+      assert_same map.exposed, map.exposed
+    end
+  end
+
+  describe "#full" do
+    it "returns memorized full map" do
+      map = Jat::Plugins::JsonApi::TraversalMap.new(jat)
+      expected_map_hash = Jat::Plugins::JsonApi::ConstructTraversalMap.new(jat_class, :all).to_h
+
+      assert_equal expected_map_hash, map.full
+      assert_same map.full, map.full
+    end
+  end
+
+  describe "#current" do
+    it "returns memorized current map" do
+      map = Jat::Plugins::JsonApi::TraversalMap.new(jat)
+      expected_map_hash = Jat::Plugins::JsonApi::Map.call(jat)
+
+      assert_equal expected_map_hash, map.current
+      assert_same map.current, map.current
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::SimpleApi::ConstructTraversalMap" do
+  before { Jat::Plugins.load_plugin(:simple_api) }
+
+  let(:described_class) { Jat::Plugins::SimpleApi::ConstructTraversalMap }
+  let(:base_class) { Class.new(Jat) { plugin :simple_api } }
+
+  let(:a) do
+    ser = Class.new(base_class)
+
+    ser.attribute :a1
+    ser.attribute :a2
+    ser.attribute :a3, exposed: false
+
+    ser.attribute :b, serializer: b
+    ser.attribute :c, serializer: c
+    ser.attribute :d, serializer: d, exposed: true
+    ser
+  end
+
+  let(:b) do
+    ser = Class.new(base_class)
+    ser.attribute :b1
+    ser.attribute :b2
+    ser.attribute :b3, exposed: false
+    ser
+  end
+
+  let(:c) do
+    ser = Class.new(base_class)
+    ser.attribute :c1
+    ser.attribute :c2
+    ser.attribute :c3, exposed: false
+    ser
+  end
+
+  let(:d) do
+    ser = Class.new(base_class)
+    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 = {
+      a1: {},
+      a2: {},
+      a3: {},
+      b: {b1: {}, b2: {}, b3: {}},
+      c: {c1: {}, c2: {}, c3: {}},
+      d: {d1: {}, d2: {}, d3: {}}
+    }
+
+    assert_equal expected_result, result
+  end
+
+  it "returns exposed attributes" do
+    result = described_class.new(a, :exposed).to_h
+    expected_result = {
+      a1: {},
+      a2: {},
+      d: {d1: {}, d2: {}}
+    }
+
+    assert_equal expected_result, result
+  end
+
+  it "returns only manually exposed attributes when `none` type provided" do
+    manually_exposed = {
+      a2: {},
+      a3: {},
+      c: {c2: {}, c3: {}},
+      d: {d2: {}, d3: {}}
+    }
+    result = described_class.new(a, :none, manually_exposed: manually_exposed).to_h
+
+    assert_equal manually_exposed, result
+  end
+
+  it "returns combined auto-exposed and manualy exposed attributes when `default` type provided" do
+    manually_exposed = {
+      b: {b3: {}}, c: {}
+    }
+    result = described_class.new(a, :default, manually_exposed: manually_exposed).to_h
+    expected_result = {
+      a1: {},
+      a2: {},
+      b: {b1: {}, b2: {}, b3: {}},
+      c: {c1: {}, c2: {}},
+      d: {d1: {}, d2: {}}
+    }
+
+    assert_equal expected_result, result
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApi::Map" do
+  before { Jat::Plugins.load_plugin(:simple_api) }
+
+  subject { Jat::Plugins::SimpleApi::Map.call(jat) }
+
+  let(:jat_class) do
+    Class.new(Jat) do
+      plugin :simple_api
+
+      attribute :a1
+      attribute :a2
+      attribute :a3, exposed: false
+      attribute :a4, exposed: false
+      attribute :a5, exposed: false
+    end
+  end
+
+  let(:jat) { jat_class.new(nil, {**params, **context}) }
+  let(:params) { {} }
+  let(:context) { {} }
+
+  describe "when no params given" do
+    it "returns map of exposed by default fields" do
+      assert_equal({a1: {}, a2: {}}, subject)
+    end
+  end
+
+  describe "when fields given" do
+    let(:params) { {params: {fields: "a2,a3,a4"}} }
+
+    it "constructs map with default and provided fields" do
+      assert_equal({a1: {}, a2: {}, a3: {}, a4: {}}, subject)
+    end
+  end
+
+  describe "with `exposed: all` context" do
+    let(:context) { {exposed: :all} }
+
+    it "constructs map with all fields" do
+      assert_equal({a1: {}, a2: {}, a3: {}, a4: {}, a5: {}}, subject)
+    end
+  end
+
+  describe "with `exposed: none` context" do
+    let(:params) { {params: {fields: "a2,a3,a4"}} }
+    let(:context) { {exposed: :none} }
+
+    it "constructs map with only requested fields" do
+      assert_equal({a2: {}, a3: {}, a4: {}}, subject)
+    end
+  end
+end