jat 0.0.3 → 0.0.8

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

@@ -3,54 +3,139 @@
 require "test_helper"
 
 describe "Jat::Plugins::SimpleApi::Map" do
-  before { Jat::Plugins.load_plugin(:simple_api) }
+  before { Jat::Plugins.find_plugin(:simple_api) }
 
-  subject { Jat::Plugins::SimpleApi::Map.call(jat) }
+  let(:base_class) { Class.new(Jat) { plugin :simple_api } }
+  let(:described_class) { a::Map }
 
-  let(:jat_class) do
-    Class.new(Jat) do
-      plugin :simple_api
+  let(:a) do
+    ser = Class.new(base_class)
 
-      attribute :a1
-      attribute :a2
-      attribute :a3, exposed: false
-      attribute :a4, exposed: false
-      attribute :a5, exposed: false
-    end
+    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(:jat) { jat_class.new(nil, {**params, **context}) }
-  let(:params) { {} }
-  let(:context) { {} }
+  let(:b) do
+    ser = Class.new(base_class)
+    ser.attribute :b1
+    ser.attribute :b2
+    ser.attribute :b3, exposed: false
+    ser
+  end
 
-  describe "when no params given" do
-    it "returns map of exposed by default fields" do
-      assert_equal({a1: {}, a2: {}}, subject)
-    end
+  let(:c) do
+    ser = Class.new(base_class)
+    ser.attribute :c1
+    ser.attribute :c2
+    ser.attribute :c3, exposed: false
+    ser
   end
 
-  describe "when fields given" do
-    let(:params) { {params: {fields: "a2,a3,a4"}} }
+  let(:d) do
+    ser = Class.new(base_class)
+    ser.attribute :d1
+    ser.attribute :d2
+    ser.attribute :d3, exposed: false
+    ser
+  end
+
+  describe ".call" do
+    it "returns all attributes when {exposed: :all} provided " do
+      result = described_class.call(exposed: :all)
+      expected_result = {
+        a1: {},
+        a2: {},
+        a3: {},
+        b: {b1: {}, b2: {}, b3: {}},
+        c: {c1: {}, c2: {}, c3: {}},
+        d: {d1: {}, d2: {}, d3: {}}
+      }
 
-    it "constructs map with default and provided fields" do
-      assert_equal({a1: {}, a2: {}, a3: {}, a4: {}}, subject)
+      assert_equal expected_result, result
     end
-  end
 
-  describe "with `exposed: all` context" do
-    let(:context) { {exposed: :all} }
+    it "returns exposed attributes when {exposed: :default} provided" do
+      result = described_class.call(exposed: :default)
+      expected_result = {
+        a1: {},
+        a2: {},
+        d: {d1: {}, d2: {}}
+      }
 
-    it "constructs map with all fields" do
-      assert_equal({a1: {}, a2: {}, a3: {}, a4: {}, a5: {}}, subject)
+      assert_equal expected_result, result
+    end
+
+    it "returns exposed attributes when no :exposed param provided" do
+      result = described_class.call({})
+      expected_result = {
+        a1: {},
+        a2: {},
+        d: {d1: {}, d2: {}}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "returns no attributes when `{exposed: :none}` provided" do
+      result = described_class.call(exposed: :none)
+      assert_equal({}, result)
     end
-  end
 
-  describe "with `exposed: none` context" do
-    let(:params) { {params: {fields: "a2,a3,a4"}} }
-    let(:context) { {exposed: :none} }
+    it "returns only manually exposed attributes when `{exposed: :none}` type provided" do
+      fields = "a2,a3,c(c2,c3),d(d2,d3)"
+      result = described_class.call(exposed: :none, fields: fields)
+
+      expected_result = {
+        a2: {},
+        a3: {},
+        c: {c2: {}, c3: {}},
+        d: {d2: {}, d3: {}}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "returns combined auto-exposed and manually exposed attributes when `default` type provided" do
+      fields = "b(b3),c"
+      result = described_class.call(exposed: :default, fields: fields)
+      expected_result = {
+        a1: {},
+        a2: {},
+        b: {b1: {}, b2: {}, b3: {}},
+        c: {c1: {}, c2: {}},
+        d: {d1: {}, d2: {}}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "raises error with informative message about recursive serialization" do
+      a.relationship :b, serializer: -> { b }, exposed: true
+      b.relationship :a, serializer: -> { a }, exposed: true
+
+      error = assert_raises(Jat::Error) { described_class.call({}) }
+      assert_includes "Recursive serialization: b -> a -> b", error.message
+    end
+
+    it "raises error with informative message about recursive serialization through 3 serializers" do
+      a.relationship :b, serializer: -> { b }, exposed: true
+      b.relationship :c, serializer: -> { c }, exposed: true
+      c.relationship :a, serializer: -> { a }, exposed: true
+
+      error = assert_raises(Jat::Error) { described_class.call({}) }
+      assert_equal "Recursive serialization: b -> c -> a -> b", error.message
+    end
+  end
 
-    it "constructs map with only requested fields" do
-      assert_equal({a2: {}, a3: {}, a4: {}}, subject)
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{a}::Map", described_class.inspect
     end
   end
 end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApi::ResponsePiece" do
+  let(:jat_class) { Class.new(Jat) { plugin :simple_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/simple_api/lib/response_test.rb

@@ -11,15 +11,9 @@ describe "Jat::Plugins::SimpleApi::Response" do
     assert_equal({}, empty_serializer.to_h(nil))
   end
 
-  it "returns correct structure with meta" do
-    empty_serializer = Class.new(base_class)
-
-    assert_equal({meta: {any: :thing}}, empty_serializer.to_h(nil, meta: {any: :thing}))
-  end
-
   it "returns correct structure with data" do
     str_serializer = Class.new(base_class) do
-      attribute(:id) { |_| "STRING" }
+      attribute(:id) { |obj| obj }
     end
 
     assert_equal({id: "STRING"}, str_serializer.to_h("STRING"))
@@ -48,18 +42,6 @@ describe "Jat::Plugins::SimpleApi::Response" do
     )
   end
 
-  it "raises error when trying to add meta to response without root key" do
-    str_serializer = Class.new(base_class) do
-      attribute(:id) { |obj| obj }
-    end
-
-    error = assert_raises(Jat::Error) { str_serializer.to_h("1", meta: {foo: :bar}) }
-    assert_equal "Response must have a root key to add metadata", error.message
-
-    error = assert_raises(Jat::Error) { str_serializer.to_h(["1"], meta: {foo: :bar}) }
-    assert_equal "Response must have a root key to add metadata", error.message
-  end
-
   it "returns correct structure with array data" do
     str_serializer = Class.new(base_class) do
       attribute(:id) { |obj| obj }
@@ -92,11 +74,10 @@ describe "Jat::Plugins::SimpleApi::Response" do
     )
   end
 
-  it "returns correct structures root_for_one and root_for_many keys" do
+  it "returns correct roots" do
     str_serializer = Class.new(base_class) do
-      root(:not_used)
-      root_for_one(:digit)
-      root_for_many(:digits)
+      root(one: :digit, many: :digits)
+
       attribute(:id) { |obj| obj }
     end
 
@@ -107,32 +88,12 @@ describe "Jat::Plugins::SimpleApi::Response" do
   it "returns correct structures when root is overwritten" do
     str_serializer = Class.new(base_class) do
       root(:root)
-      root_for_one(:root)
-      root_for_many(:root)
       attribute(:id) { |obj| obj }
     end
 
     assert_equal({foo: {id: "1"}}, str_serializer.to_h("1", root: :foo))
-    assert_equal({foo: [{id: "1"}]}, str_serializer.to_h(["1"], root: :foo))
-  end
-
-  it "returns correct structure with data and meta" do
-    str_serializer = Class.new(base_class) do
-      root(:root)
-      config[:meta] = {version: "1.2.3"}
-
-      attribute(:id) { |obj| obj }
-    end
-
-    assert_equal(
-      {root: {id: "1"}, meta: {any: :thing, version: "1.2.3"}},
-      str_serializer.to_h("1", meta: {any: :thing})
-    )
-
-    assert_equal(
-      {root: [{id: "1"}], meta: {any: :thing, version: "1.2.3"}},
-      str_serializer.to_h(["1"], meta: {any: :thing})
-    )
+    assert_equal({foo: {id: "1"}}, str_serializer.to_h("1", root: "foo"))
+    assert_equal({id: "1"}, str_serializer.to_h("1", root: nil))
   end
 
   it "returns correct structure with data multiple attributes" do
@@ -293,50 +254,103 @@ describe "Jat::Plugins::SimpleApi::Response" do
 
     assert_equal(
       {chars: [{next: "b"}, {next: "c"}]},
-      str_serializer.to_h("ab", params: {fields: "chars(next)"})
+      str_serializer.to_h("ab", fields: "chars(next)")
     )
   end
 
-  it "does not overwrite manually added meta" do
-    str_serializer = Class.new(base_class) do
-      root(:root)
-      config[:meta] = {version: "1.2.3"}
+  describe "adding meta" do
+    it "returns correct structure with only meta" do
+      empty_serializer = Class.new(base_class)
 
-      attribute(:id) { |obj| obj }
+      assert_equal({meta: {any: :thing}}, empty_serializer.to_h(nil, meta: {any: :thing}))
     end
 
-    assert_equal(
-      {root: {id: "1"}, meta: {version: "2.0.0"}},
-      str_serializer.to_h("1", meta: {version: "2.0.0"})
-    )
-  end
+    it "returns correct structure with overwritten meta key" do
+      empty_serializer = Class.new(base_class)
+      empty_serializer.meta_key :metadata
+      empty_serializer.meta(:foo) { :bar }
 
-  it "allows to provide lambda as meta key" do
-    str_serializer = Class.new(base_class) do
-      root(:root)
-      config[:meta] = {
-        obj: ->(obj, _context) { obj },
-        context: ->(_obj, context) { context },
-        time: ->(_obj, _context) { Time.new(2020, 1, 1) }
-      }
+      assert_equal({metadata: {foo: :bar}}, empty_serializer.to_h(nil))
+      assert_equal({new_meta: {foo: :bar}}, empty_serializer.to_h(nil, meta_key: "new_meta"))
+    end
 
-      attribute(:id) { |obj| obj }
+    it "returns correct structure with data and meta" do
+      str_serializer = Class.new(base_class) do
+        root(:root)
+        meta(:version) { "1.2.3" }
+
+        attribute(:id) { |obj| obj }
+      end
+
+      assert_equal(
+        {root: {id: "1"}, meta: {any: :thing, version: "1.2.3"}},
+        str_serializer.to_h("1", meta: {any: :thing})
+      )
+
+      assert_equal(
+        {root: [{id: "1"}], meta: {any: :thing, version: "1.2.3"}},
+        str_serializer.to_h(["1"], meta: {any: :thing})
+      )
     end
 
-    assert_equal(
-      {root: {id: "1"}, meta: {obj: "1", context: {foo: :bar}, time: Time.new(2020, 1, 1)}},
-      str_serializer.to_h("1", foo: :bar)
-    )
-  end
+    it "raises error when trying to add meta to response without root key" do
+      str_serializer = Class.new(base_class) do
+        attribute(:id) { |obj| obj }
+      end
 
-  it "does not adds nil meta" do
-    str_serializer = Class.new(base_class) do
-      root(:root)
-      config[:meta] = {foo: nil, bar: proc {}}
+      error = assert_raises(Jat::Error) { str_serializer.to_h("1", meta: {foo: :bar}) }
+      assert_equal "Response must have a root key to add metadata", error.message
 
-      attribute(:id) { |obj| obj }
+      error = assert_raises(Jat::Error) { str_serializer.to_h(["1"], meta: {foo: :bar}) }
+      assert_equal "Response must have a root key to add metadata", error.message
     end
 
-    assert_equal({root: {id: "1"}}, str_serializer.to_h("1", bazz: nil))
+    it "does not overwrite manually added meta" do
+      str_serializer = Class.new(base_class) do
+        root(:root)
+        meta(:version) { "1.2.3" }
+
+        attribute(:id) { |obj| obj }
+      end
+
+      assert_equal(
+        {root: {id: "1"}, meta: {version: "2.0.0"}},
+        str_serializer.to_h("1", meta: {version: "2.0.0"})
+      )
+    end
+
+    it "allows to provide lambda as meta key" do
+      str_serializer = Class.new(base_class) do
+        root(:root)
+
+        meta(:obj) { |obj| obj }
+        meta(:context) { |_obj, context| context }
+        meta(:time) { Time.new(2020, 1, 1) }
+
+        attribute(:id) { |obj| obj }
+      end
+
+      assert_equal(
+        {root: {id: "1"}, meta: {obj: "1", context: {foo: :bar}, time: Time.new(2020, 1, 1)}},
+        str_serializer.to_h("1", foo: :bar)
+      )
+    end
+
+    it "does not adds nil meta" do
+      str_serializer = Class.new(base_class) do
+        root(:root)
+        meta(:foo) {}
+
+        attribute(:id) { |obj| obj }
+      end
+
+      assert_equal({root: {id: "1"}}, str_serializer.to_h("1", bazz: nil))
+    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/simple_api/simple_api_test.rb

@@ -3,7 +3,7 @@
 require "test_helper"
 
 describe "Jat::Plugins::SimpleApi" do
-  before { @plugin = Jat::Plugins.load_plugin(:simple_api) }
+  before { @plugin = Jat::Plugins.find_plugin(:simple_api) }
 
   let(:jat_class) do
     new_class = Class.new(Jat)
@@ -15,66 +15,159 @@ describe "Jat::Plugins::SimpleApi" do
 
   let(:plugin) { @plugin }
 
+  describe ".before_load" do
+    it "raises error if response plugin was already loaded" do
+      jat_class = Class.new(Jat)
+      jat_class.config[:response_plugin_loaded] = :foobar
+
+      err = assert_raises(Jat::Error) { jat_class.plugin(:simple_api) }
+      assert_equal("Response plugin `foobar` was already loaded before", err.message)
+    end
+  end
+
   describe ".after_load" do
-    it "loads _json_api_activerecord plugin if activerecord option provided" do
+    it "adds default `:meta` meta_key config option" do
+      jat_class = Class.new(Jat)
+      assert_nil jat_class.config[:meta_key]
+
+      plugin.load(jat_class)
+      plugin.after_load(jat_class)
+      assert_equal :meta, jat_class.config[:meta_key]
+    end
+
+    it "adds config variable with name of response plugin that was loaded" do
       jat_class = Class.new(Jat)
-      jat_class.expects(:plugin).with(:_json_api_activerecord, activerecord: true)
+      jat_class.plugin(:simple_api)
 
-      Jat::Plugins.after_load(plugin, jat_class, activerecord: true)
+      assert_equal(:simple_api, jat_class.config[:response_plugin_loaded])
     end
   end
 
   describe "InstanceMethods" do
-    let(:jat) { jat_class.new("JAT", {}) }
+    let(:jat) { jat_class.new({}) }
 
     describe "#to_h" do
       it "returns response in a simple-api format" do
         expected_result = {data: {id: "JAT"}}
-        assert_equal expected_result, jat.to_h
+        assert_equal expected_result, jat.to_h("JAT")
       end
     end
 
-    describe "#traversal_map" do
-      it "returns memorized traversal_map hash" do
-        assert_equal jat.traversal_map.class, Hash
-        assert_same jat.traversal_map, jat.traversal_map
+    describe "#map" do
+      it "returns map for provided context" do
+        jat_class::Map.expects(:call).with("CONTEXT").returns "MAP"
+        assert_equal "MAP", jat_class.new("CONTEXT").map
       end
     end
-  end
 
-  describe "ClassMethods" do
-    describe ".inherited" do
-      it "inherits root" do
-        child = Class.new(jat_class)
-        assert_equal :data, child.root
+    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 ".root" do
-      it "saves and returns current root" do
-        assert_equal :data, jat_class.root
+      it "sets root config values" do
+        jat_class.root :data
+
+        assert_equal :data, jat_class.config[:root_one]
+        assert_equal :data, jat_class.config[:root_many]
+      end
+
+      it "sets root config values separately for one or many objects" do
+        jat_class.root one: "user", many: "users"
+
+        assert_equal :user, jat_class.config[:root_one]
+        assert_equal :users, jat_class.config[:root_many]
+      end
+
+      it "removes root values when `false` or `nil` provided" do
+        jat_class.root :data
+        jat_class.root false
+
+        assert_nil jat_class.config[:root_one]
+        assert_nil jat_class.config[:root_many]
+
+        jat_class.root :data
+        jat_class.root nil
+
+        assert_nil jat_class.config[:root_one]
+        assert_nil jat_class.config[:root_many]
+      end
+
+      it "removes root values when `false` or nil provided in hash" do
+        jat_class.root :data
+        jat_class.root one: nil, many: nil
+        assert_nil jat_class.config[:root_one]
+        assert_nil jat_class.config[:root_many]
+
+        jat_class.root :data
+        jat_class.root one: false, many: false
+        assert_nil jat_class.config[:root_one]
+        assert_nil jat_class.config[:root_many]
       end
 
       it "symbolizes root" do
-        jat_class.root "users"
-        assert_equal :users, jat_class.root
+        jat_class.root "data"
+        assert_equal :data, jat_class.config[:root_one]
+        assert_equal :data, jat_class.config[:root_many]
+
+        jat_class.root one: "user", many: "users"
+        assert_equal :user, jat_class.config[:root_one]
+        assert_equal :users, jat_class.config[:root_many]
       end
     end
 
     describe ".meta_key" do
       it "returns default meta_key" do
-        assert_equal :meta, jat_class.meta_key
+        assert_equal :meta, jat_class.config[:meta_key]
       end
 
-      it "saves and returns meta key" do
+      it "changes meta key" do
         jat_class.meta_key :metadata
-        assert_equal :metadata, jat_class.meta_key
-        assert_same jat_class.meta_key, jat_class.meta_key
+        assert_equal :metadata, jat_class.config[:meta_key]
       end
 
       it "symbolizes meta key" do
         jat_class.meta_key "metadata"
-        assert_equal :metadata, jat_class.meta_key
+        assert_equal :metadata, jat_class.config[:meta_key]
+      end
+    end
+
+    describe ".inherited" do
+      it "inherits root" do
+        jat_class.root(:foo)
+        child = Class.new(jat_class)
+        assert_equal :foo, child.config[:root_one]
+        assert_equal :foo, child.config[:root_many]
+      end
+
+      it "inherits meta" do
+        jat_class.meta(:foo) { "bar" }
+        child = Class.new(jat_class)
+
+        assert_equal "bar", child.added_meta[:foo].value(nil, nil)
+      end
+
+      it "does not change parents meta when children meta changed" do
+        jat_class.meta(:foo) { "foo" }
+        child = Class.new(jat_class)
+        child.meta(:foo) { "bazz" }
+
+        assert_equal("foo", jat_class.added_meta[:foo].value(nil, nil))
+        assert_equal("bazz", child.added_meta[:foo].value(nil, nil))
       end
     end
   end

data/test/lib/jat/plugins/simple_api_activerecord/simple_api_activerecord_test.rb

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

data/test/lib/jat/plugins/simple_api_lower_camel_case/simple_api_lower_camel_case_test.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApiLowerCamelCase" do
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.plugin(:simple_api)
+    new_class.plugin(:simple_api_lower_camel_case)
+    new_class
+  end
+
+  it "checks simple_api plugin loaded before" do
+    jat_class = Class.new(Jat)
+    error = assert_raises(Jat::Error) { jat_class.plugin :simple_api_lower_camel_case }
+    assert_match(/simple_api/, error.message)
+  end
+
+  it "loads _lower_camel_case plugin" do
+    assert jat_class.plugin_used?(:base_lower_camel_case)
+  end
+
+  it "returns attributes in lowerCamelCase case" do
+    jat_class.attribute(:foo_bar) { 1 }
+
+    response = jat_class.to_h(true)
+    assert_equal({fooBar: 1}, response)
+  end
+
+  it "accepts fields in lowerCamelCase format" do
+    jat_class.attribute(:foo_bar, exposed: false) { 1 }
+
+    response = jat_class.to_h(true, fields: "fooBar")
+    assert_equal({fooBar: 1}, response)
+  end
+
+  it "returns meta keys in lowerCamelCase format" do
+    jat_class.meta(:user_agent) { "Firefox" }
+
+    response = jat_class.to_h(nil)
+    assert_equal({meta: {userAgent: "Firefox"}}, response)
+  end
+
+  it "returns context meta keys in lowerCamelCase format" do
+    response = jat_class.to_h(nil, meta: {user_agent: "Firefox"})
+    assert_equal({meta: {userAgent: "Firefox"}}, response)
+  end
+
+  it "joins meta in lowerCamelCase format" do
+    jat_class.meta(:userAgent) { "Firefox" }
+    response = jat_class.to_h(nil, meta: {user_agent: "Firefox 2.0"})
+    assert_equal({meta: {userAgent: "Firefox 2.0"}}, response)
+  end
+end