jat 0.0.3 → 0.0.5

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

@@ -3,54 +3,131 @@
 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(: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 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: {}}
+    }
+
+    assert_equal expected_result, result
   end
 
-  let(:jat) { jat_class.new(nil, {**params, **context}) }
-  let(:params) { {} }
-  let(:context) { {} }
+  it "returns exposed attributes when {exposed: :default} provided" do
+    result = described_class.call(exposed: :default)
+    expected_result = {
+      a1: {},
+      a2: {},
+      d: {d1: {}, d2: {}}
+    }
+
+    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
+
+  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: {}}
+    }
 
-  describe "when no params given" do
-    it "returns map of exposed by default fields" do
-      assert_equal({a1: {}, a2: {}}, subject)
-    end
+    assert_equal expected_result, result
   end
 
-  describe "when fields given" do
-    let(:params) { {params: {fields: "a2,a3,a4"}} }
+  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: {}}
+    }
 
-    it "constructs map with default and provided fields" do
-      assert_equal({a1: {}, a2: {}, a3: {}, a4: {}}, subject)
-    end
+    assert_equal expected_result, result
   end
 
-  describe "with `exposed: all` context" do
-    let(:context) { {exposed: :all} }
+  it "raises error with informative message about recursive serialization" do
+    a.relationship :b, serializer: -> { b }, exposed: true
+    b.relationship :a, serializer: -> { a }, exposed: true
 
-    it "constructs map with all fields" do
-      assert_equal({a1: {}, a2: {}, a3: {}, a4: {}, a5: {}}, subject)
-    end
+    error = assert_raises(Jat::Error) { described_class.call({}) }
+    assert_includes "Recursive serialization: b -> a -> b", error.message
   end
 
-  describe "with `exposed: none` context" do
-    let(:params) { {params: {fields: "a2,a3,a4"}} }
-    let(:context) { {exposed: :none} }
+  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
 
-    it "constructs map with only requested fields" do
-      assert_equal({a2: {}, a3: {}, a4: {}}, subject)
-    end
+    error = assert_raises(Jat::Error) { described_class.call({}) }
+    assert_equal "Recursive serialization: b -> c -> a -> b", error.message
   end
 end

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

@@ -11,12 +11,6 @@ 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" }
@@ -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,8 +88,6 @@ 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
 
@@ -116,25 +95,6 @@ describe "Jat::Plugins::SimpleApi::Response" do
     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})
-    )
-  end
-
   it "returns correct structure with data multiple attributes" do
     str_serializer = Class.new(base_class) do
       attribute(:id) { |obj| obj }
@@ -293,50 +253,96 @@ 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, any: :thing}}, empty_serializer.to_h(nil, meta: {any: :thing}))
+    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
+
+    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
 
-    assert_equal({root: {id: "1"}}, str_serializer.to_h("1", bazz: nil))
+    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
 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)
@@ -16,65 +16,131 @@ describe "Jat::Plugins::SimpleApi" do
   let(:plugin) { @plugin }
 
   describe ".after_load" do
-    it "loads _json_api_activerecord plugin if activerecord option provided" do
+    it "loads simple_api_activerecord plugin if activerecord option provided" do
       jat_class = Class.new(Jat)
-      jat_class.expects(:plugin).with(:_json_api_activerecord, activerecord: true)
+      jat_class.expects(:plugin).with(:simple_api_activerecord, activerecord: true)
 
-      Jat::Plugins.after_load(plugin, jat_class, activerecord: true)
+      plugin.load(jat_class)
+      plugin.after_load(jat_class, activerecord: true)
+    end
+
+    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.plugin(:simple_api)
+
+      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.map("CONTEXT")
       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
   end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApiActiverecord::Preloads" do
+  let(:base) { Class.new(Jat) { plugin :simple_api, activerecord: true } }
+
+  let(:user_serializer) { Class.new(base) }
+  let(:profile_serializer) { Class.new(base) }
+  let(:email_serializer) { Class.new(base) }
+
+  let(:jat_user) { user_serializer.new }
+  let(:jat_profile) { profile_serializer.new }
+  let(:jat_email) { email_serializer.new }
+
+  let(:described_class) { Jat::Plugins::SimpleApiActiverecord::Preloads }
+
+  def define_map(map)
+    user_serializer::Map.expects(:call).returns(map)
+  end
+
+  it "returns empty hash when no attributes requested" do
+    define_map({})
+
+    result = described_class.call(jat_user)
+    assert_equal({}, result)
+  end
+
+  it "returns empty hash when no attributes with preloads requested" do
+    user_serializer.attribute :name
+    define_map({name: {}})
+
+    result = described_class.call(jat_user)
+    assert_equal({}, result)
+  end
+
+  it "returns preloads for requested attributes" do
+    user_serializer.attribute :name, preload: :profile
+    define_map({name: {}})
+
+    result = described_class.call(jat_user)
+    assert_equal({profile: {}}, result)
+  end
+
+  it "returns merged preloads for requested attributes" do
+    user_serializer.attribute :first_name, preload: :profile
+    user_serializer.attribute :phone, preload: {profile: :phones}
+    user_serializer.attribute :email, preload: {profile: :emails}
+
+    define_map({first_name: {}, phone: {}, email: {}})
+
+    result = described_class.call(jat_user)
+    assert_equal({profile: {phones: {}, emails: {}}}, result)
+  end
+
+  it "returns no preloads and no nested preloads for relationships when specified preloads is nil" do
+    user_serializer.relationship :profile, serializer: profile_serializer, preload: nil
+    profile_serializer.attribute :email, preload: :email # should not be preloaded
+    define_map(profile: {email: {}})
+
+    result = described_class.call(jat_user)
+    assert_equal({}, result)
+  end
+
+  it "returns preloads for nested relationships joined to root when specified preloads is {}" do
+    user_serializer.relationship :profile, serializer: profile_serializer, preload: {}
+    profile_serializer.attribute :email, preload: :email # should be preloaded to root
+    define_map({profile: {email: {}}})
+
+    result = described_class.call(jat_user)
+    assert_equal({email: {}}, result)
+  end
+
+  it "returns preloads for nested relationships joined to root when specified preloads is []" do
+    user_serializer.relationship :profile, serializer: profile_serializer, preload: []
+    profile_serializer.attribute :email, preload: :email # should be preloaded to root
+    define_map({profile: {email: {}}})
+
+    result = described_class.call(jat_user)
+    assert_equal({email: {}}, result)
+  end
+
+  it "returns preloads for relationships" do
+    user_serializer.relationship :profile, serializer: profile_serializer
+    define_map(profile: {})
+
+    result = described_class.call(jat_user)
+    assert_equal({profile: {}}, result)
+  end
+
+  it "returns nested preloads for relationships" do
+    user_serializer.relationship :profile, serializer: profile_serializer
+    profile_serializer.attribute :email, preload: %i[confirmed_email unconfirmed_email]
+    define_map(profile: {email: {}})
+
+    result = described_class.call(jat_user)
+    assert_equal({profile: {confirmed_email: {}, unconfirmed_email: {}}}, result)
+  end
+
+  it "preloads nested relationships for nested relationship" do
+    user_serializer.relationship :profile, serializer: profile_serializer, preload: {company: :profile}
+    profile_serializer.attribute :email, preload: %i[confirmed_email unconfirmed_email]
+    define_map(profile: {email: {}})
+
+    result = described_class.call(jat_user)
+    assert_equal({company: {profile: {confirmed_email: {}, unconfirmed_email: {}}}}, result)
+  end
+
+  it "preloads nested relationships to main (!) resource" do
+    user_serializer.relationship :profile, serializer: profile_serializer, preload: {company!: :profile}
+    profile_serializer.attribute :email, preload: %i[confirmed_email unconfirmed_email]
+    define_map(profile: {email: {}})
+
+    result = described_class.call(jat_user)
+    assert_equal({company: {profile: {}, confirmed_email: {}, unconfirmed_email: {}}}, result)
+  end
+
+  it "merges preloads the same way regardless of order of preloads" do
+    a = Class.new(base)
+    a.attribute :a1, preload: {foo: {bar: {bazz1: {}, bazz: {}}}}
+    a.attribute :a2, preload: {foo: {bar: {bazz2: {}, bazz: {last: {}}}}}
+
+    jat_a1 = a.allocate
+    jat_a2 = a.allocate
+
+    jat_a1.expects(:map).returns({a1: {}, a2: {}})
+    jat_a2.expects(:map).returns({a2: {}, a1: {}})
+
+    result1 = described_class.call(jat_a1)
+    result2 = described_class.call(jat_a2)
+
+    assert_equal(result2, result1)
+    assert_equal({foo: {bar: {bazz: {last: {}}, bazz1: {}, bazz2: {}}}}, result1)
+  end
+end