jat 0.0.3 → 0.0.8

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

@@ -3,115 +3,194 @@
 require "test_helper"
 
 describe "Jat::Plugins::JsonApi::Map" do
-  subject { Jat::Plugins::JsonApi::Map.call(jat) }
+  before { Jat::Plugins.find_plugin(:json_api) }
 
-  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} }
+  let(:described_class) { a::Map }
+  let(:base_class) { Class.new(Jat) { plugin :json_api } }
 
-  before do
-    jat.traversal_map.expects(:exposed).returns(default_map)
-  end
+  let(:a) do
+    ser = Class.new(base_class)
+    ser.type :a
 
-  describe "when no params given" do
-    let(:param_includes) { nil }
-    let(:param_fields) { nil }
+    ser.attribute :a1
+    ser.attribute :a2
+    ser.attribute :a3, exposed: false
 
-    it "returns map of exposed by default fields" do
-      assert_equal default_map, subject
-    end
+    ser.relationship :b, serializer: b, exposed: true
+    ser.relationship :c, serializer: c
+    ser.relationship :d, serializer: d
+    ser
   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)
+  let(:b) do
+    ser = Class.new(base_class)
+    ser.type :b
+    ser.attribute :b1
+    ser.attribute :b2
+    ser.attribute :b3, exposed: false
 
-      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
+    ser.relationship :c, serializer: c
+    ser.relationship :d, serializer: d
+    ser
   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)
+  let(:c) do
+    ser = Class.new(base_class)
+    ser.type :c
+    ser.attribute :c1
+    ser.attribute :c2
+    ser.attribute :c3, exposed: false
+    ser
+  end
 
-      Jat::Plugins::JsonApi::Params::Include
-        .expects(:call)
-        .with(jat, "INCLUDES")
-        .returns("PARSED_INCLUDES")
+  let(:d) do
+    ser = Class.new(base_class)
+    ser.type :d
+    ser.attribute :d1
+    ser.attribute :d2
+    ser.attribute :d3, exposed: false
+    ser
+  end
 
-      Jat::Plugins::JsonApi::ConstructTraversalMap
-        .expects(:new)
-        .with(jat_class, :exposed, manually_exposed: "PARSED_INCLUDES")
-        .returns(constructor)
+  describe ".call" do
+    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
 
-    it "constructs map with default and included fields" do
-      assert_equal({a: :a1, b: :b2, c: :c2}, subject)
+    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
-  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)
+    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
 
-    it "constructs map with using everything: defaults, includes, fields" do
-      assert_equal({a: :a1, b: :b2, c: :c3}, subject)
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{a}::Map", described_class.inspect
     end
   end
 end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::ResponsePiece" do
+  let(:jat_class) { Class.new(Jat) { plugin :json_api } }
+
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{jat_class}::ResponsePiece", jat_class::ResponsePiece.inspect
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "returns correct structure with data" do
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |_| "STRING" }
+      id { |_| "STRING" }
     end
 
     assert_equal({data: {type: :str, id: "STRING"}}, str_serializer.to_h("STRING"))
@@ -23,7 +23,7 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "returns correct structure with array data" do
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |obj| obj }
+      id { |obj| obj }
     end
 
     assert_equal(
@@ -35,7 +35,7 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "returns correct structure with data with attributes" do
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |obj| obj[0] }
+      id { |obj| obj[0] }
       attribute :length
     end
 
@@ -48,12 +48,12 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "returns correct structure with has-one relationship" do
     int_serializer = Class.new(base_class) do
       type "int"
-      attribute(:id) { |obj| obj }
+      id { |obj| obj }
     end
 
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |obj| obj[0] }
+      id { |obj| obj[0] }
       relationship :length, serializer: int_serializer, exposed: true
     end
 
@@ -76,12 +76,12 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "does not return has-one relationship when not exposed" do
     int_serializer = Class.new(base_class) do
       type "int"
-      attribute(:id) { |obj| obj }
+      id { |obj| obj }
     end
 
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |obj| obj[0] }
+      id { |obj| obj[0] }
       relationship :length, serializer: int_serializer # relationships are not exposed by default
     end
 
@@ -91,7 +91,7 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "returns correct structure with empty has-one relationship" do
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |obj| obj[0] }
+      id { |obj| obj[0] }
       relationship(:length, serializer: self, exposed: true) { |_obj| nil }
     end
 
@@ -109,13 +109,13 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "returns correct structure with has-one relationship with attributes" do
     int_serializer = Class.new(base_class) do
       type "int"
-      attribute(:id) { |obj| obj }
+      id { |obj| obj }
       attribute(:next) { |obj| obj + 1 }
     end
 
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |obj| obj[0] }
+      id { |obj| obj[0] }
       relationship :length, serializer: int_serializer, exposed: true
     end
 
@@ -142,7 +142,7 @@ describe "Jat::Plugins::JsonApi::Response" do
 
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |_obj| "id" }
+      id { |_obj| "id" }
       relationship :chars, serializer: chr_serializer, many: true, exposed: true
     end
 
@@ -160,12 +160,12 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "returns correct structure with has-many relationship" do
     chr_serializer = Class.new(base_class) do
       type "chr"
-      attribute(:id) { |obj| obj }
+      id { |obj| obj }
     end
 
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |obj| obj[0] }
+      id { |obj| obj[0] }
       relationship :chars, serializer: chr_serializer, many: true, exposed: true
     end
 
@@ -188,13 +188,13 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "returns correct structure with has-many relationship with attributes" do
     chr_serializer = Class.new(base_class) do
       type "chr"
-      attribute(:id) { |obj| obj }
+      id { |obj| obj }
       attribute :next
     end
 
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |obj| obj[0] }
+      id { |obj| obj[0] }
       relationship :chars, serializer: chr_serializer, many: true, exposed: true
     end
 
@@ -218,12 +218,12 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "accepts includes param" do
     chr_serializer = Class.new(base_class) do
       type "chr"
-      attribute(:id) { |obj| obj }
+      id { |obj| obj }
     end
 
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |obj| obj[0] }
+      id { |obj| obj[0] }
       relationship :chars, serializer: chr_serializer, many: true, exposed: false
     end
 
@@ -239,19 +239,19 @@ describe "Jat::Plugins::JsonApi::Response" do
           {type: :chr, id: "a"}, {type: :chr, id: "b"}
         ]
       },
-      str_serializer.to_h("ab", params: {include: "chars"})
+      str_serializer.to_h("ab", include: "chars")
     )
   end
 
   it "accepts sparse_fieldset" do
     chr_serializer = Class.new(base_class) do
       type "chr"
-      attribute(:id) { |obj| obj }
+      id { |obj| obj }
     end
 
     str_serializer = Class.new(base_class) do
       type "str"
-      attribute(:id) { |obj| obj[0] }
+      id { |obj| obj[0] }
       relationship :chars, serializer: chr_serializer, many: true, exposed: false
     end
 
@@ -267,7 +267,7 @@ describe "Jat::Plugins::JsonApi::Response" do
           {type: :chr, id: "a"}, {type: :chr, id: "b"}
         ]
       },
-      str_serializer.to_h("ab", params: {fields: {str: "chars"}})
+      str_serializer.to_h("ab", fields: {str: "chars"})
     )
   end
 
@@ -275,7 +275,7 @@ describe "Jat::Plugins::JsonApi::Response" do
     let(:serializer) do
       Class.new(base_class) do
         type :foo
-        attribute(:id) { |obj| obj }
+        id { |obj| obj }
       end
     end
 
@@ -311,7 +311,7 @@ describe "Jat::Plugins::JsonApi::Response" do
     let(:serializer) do
       Class.new(base_class) do
         type :foo
-        attribute(:id) { |obj| obj }
+        id { |obj| obj }
       end
     end
 
@@ -347,7 +347,7 @@ describe "Jat::Plugins::JsonApi::Response" do
     let(:serializer) do
       Class.new(base_class) do
         type :foo
-        attribute(:id) { |obj| obj }
+        id { |obj| obj }
       end
     end
 
@@ -374,21 +374,21 @@ describe "Jat::Plugins::JsonApi::Response" do
     let(:bar_serializer) do
       Class.new(base_class) do
         type :bar
-        attribute(:id) { |obj| obj }
+        id { |obj| obj }
       end
     end
 
     let(:foo_serializer) do
       Class.new(base_class) do
         type :foo
-        attribute(:id) { |obj| obj }
+        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(:uid) { |obj, context| [context[:parent_object], obj, context[:time]] }
       bar_serializer.relationship_meta(:null) {}
 
       response = foo_serializer.to_h("foo", time: "12:00")
@@ -401,7 +401,7 @@ describe "Jat::Plugins::JsonApi::Response" do
     let(:serializer) do
       Class.new(base_class) do
         type :foo
-        attribute(:id) { |obj| obj }
+        id { |obj| obj }
       end
     end
 
@@ -437,7 +437,7 @@ describe "Jat::Plugins::JsonApi::Response" do
     let(:serializer) do
       Class.new(base_class) do
         type :foo
-        attribute(:id) { |obj| obj }
+        id { |obj| obj }
       end
     end
 
@@ -464,21 +464,21 @@ describe "Jat::Plugins::JsonApi::Response" do
     let(:bar_serializer) do
       Class.new(base_class) do
         type :bar
-        attribute(:id) { |obj| obj }
+        id { |obj| obj }
       end
     end
 
     let(:foo_serializer) do
       Class.new(base_class) do
         type :foo
-        attribute(:id) { |obj| obj }
+        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(:related) { |_obj, ctx| "/#{ctx[:parent_object]}/self" }
       bar_serializer.relationship_link(:null) {}
 
       response = foo_serializer.to_h("foo")
@@ -486,4 +486,10 @@ describe "Jat::Plugins::JsonApi::Response" do
       assert_equal({self: "/self", related: "/foo/self"}, links)
     end
   end
+
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{base_class}::Response", base_class::Response.inspect
+    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?(:base_activerecord_preloads)
+  end
+end

data/test/lib/jat/plugins/json_api_lower_camel_case/json_api_lower_camel_case_test.rb

@@ -0,0 +1,85 @@
+# 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 "checks json_api plugin loaded before" do
+    jat_class = Class.new(Jat)
+    error = assert_raises(Jat::Error) { jat_class.plugin :json_api_lower_camel_case }
+    assert_match(/json_api/, error.message)
+  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