jat 0.0.1 → 0.0.3

data/test/lib/jat/attribute_test.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat::Attribute do
+  let(:jat_class) { Class.new(Jat) }
+  let(:attribute_class) { jat_class::Attribute }
+
+  describe ".jat_class=" do
+    it "assigns @jat_class" do
+      attribute_class.jat_class = :foo
+      assert_equal :foo, attribute_class.instance_variable_get(:@jat_class)
+    end
+  end
+
+  describe ".jat_class" do
+    it "returns self @jat_class" do
+      assert_same jat_class, attribute_class.instance_variable_get(:@jat_class)
+      assert_same jat_class, attribute_class.jat_class
+    end
+  end
+
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{jat_class}::Attribute", attribute_class.inspect
+    end
+  end
+
+  describe "#initialize" do
+    it "deeply copies provided params" do
+      params = {name: :foo, opts: {include: {foo: :bar}}, block: -> {}}
+
+      attribute = attribute_class.new(**params)
+      assert_equal attribute.params, params
+      refute_same attribute.params, params
+      refute_same attribute.opts, params[:opts]
+    end
+  end
+
+  describe "#name" do
+    it "symbolizes name" do
+      attribute = attribute_class.new(name: "foo")
+      assert_equal :foo, attribute.name
+    end
+  end
+
+  describe "#key" do
+    it "returns same as #name when key not provided" do
+      attribute = attribute_class.new(name: "foo")
+      assert_equal :foo, attribute.key
+    end
+
+    it "returns symbolized key option" do
+      attribute = attribute_class.new(name: "foo", opts: {key: "bar"})
+      assert_equal :bar, attribute.key
+    end
+  end
+
+  describe "#exposed?" do
+    it "returns provided value" do
+      attribute = attribute_class.new(name: "foo", opts: {exposed: false})
+      assert_equal false, attribute.exposed?
+    end
+
+    it "returns true when all keys are exposed by config" do
+      jat_class.config[:exposed] = :all
+      attribute = attribute_class.new(name: "foo")
+      assert_equal true, attribute.exposed?
+    end
+
+    it "returns false when no keys are exposed by config" do
+      jat_class.config[:exposed] = :none
+      attribute = attribute_class.new(name: "foo")
+      assert_equal false, attribute.exposed?
+    end
+
+    it "returns false when serializer exists and config[:exposed] is default" do
+      jat_class.config[:exposed] = :default
+      attribute = attribute_class.new(name: "foo", opts: {serializer: jat_class})
+      assert_equal false, attribute.exposed?
+    end
+
+    it "returns true when serializer not exists and config[:exposed] is default" do
+      jat_class.config[:exposed] = :default
+      attribute = attribute_class.new(name: "foo")
+      assert_equal true, attribute.exposed?
+    end
+  end
+
+  describe "#many?" do
+    it "returns nil when no key provided" do
+      attribute = attribute_class.new(name: "foo")
+      assert_nil attribute.many?
+    end
+
+    it "returns provided data" do
+      attribute = attribute_class.new(name: "foo", opts: {many: false})
+      assert_equal false, attribute.many?
+      assert_equal false, attribute.instance_variable_get(:@many)
+      assert_same attribute.instance_variable_get(:@many), attribute.many?
+    end
+  end
+
+  describe "#relation?" do
+    it "returns false when no serializer key" do
+      attribute = attribute_class.new(name: "foo")
+      assert_equal false, attribute.relation?
+    end
+
+    it "returns true with serializer key" do
+      attribute = attribute_class.new(name: "foo", opts: {serializer: jat_class})
+      assert_equal true, attribute.relation?
+    end
+  end
+
+  describe "#serializer" do
+    it "returns nil when no serializer key" do
+      attribute = attribute_class.new(name: "foo")
+      assert_nil attribute.serializer
+    end
+
+    it "returns provided serializer" do
+      attribute = attribute_class.new(name: "foo", opts: {serializer: jat_class})
+      assert_same jat_class, attribute.serializer
+    end
+  end
+
+  describe "#block" do
+    it "returns provided block" do
+      block = -> {}
+      attribute = attribute_class.new(name: "foo", block: block)
+      assert_equal block, attribute.block
+    end
+
+    it "constructs block that calls current key method on object" do
+      attribute = attribute_class.new(name: "foo", opts: {key: :length})
+      presenter = jat_class::Presenter.new([1, 2, 3], {})
+
+      assert_equal 3, presenter.instance_exec(&attribute.block)
+    end
+  end
+end

data/test/lib/jat/config_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat::Config do
+  let(:jat_class) { Class.new(Jat) }
+  let(:config) { jat_class.config }
+
+  describe ".jat_class=" do
+    it "assigns @jat_class" do
+      config.class.jat_class = :foo
+      assert_equal :foo, config.class.instance_variable_get(:@jat_class)
+    end
+  end
+
+  describe ".jat_class" do
+    it "returns self @jat_class" do
+      assert_same jat_class, config.class.instance_variable_get(:@jat_class)
+      assert_same jat_class, config.class.jat_class
+    end
+  end
+
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{jat_class}::Config", config.class.inspect
+    end
+  end
+
+  describe "#initialize" do
+    it "deeply copies provided opts" do
+      opts = {foo: {bar: {bazz: :bazz2}}}
+
+      config = Jat::Config.new(opts)
+      assert_equal config.opts, opts
+      refute_same config.opts[:foo], opts[:foo]
+      refute_same config.opts[:foo][:bar], opts[:foo][:bar]
+    end
+  end
+
+  describe "#[]=" do
+    it "adds options" do
+      config = Jat::Config.new
+      config[:foo] = :bar
+
+      assert_equal :bar, config.opts[:foo]
+    end
+  end
+
+  describe "#[]" do
+    it "reads options" do
+      config = Jat::Config.new
+      config[:foo] = :bar
+
+      assert_equal :bar, config[:foo]
+    end
+  end
+end

data/test/lib/jat/plugins/_activerecord_preloads/_activerecord_preloads_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::ActiverecordPreloads" do
+  let(:jat_class) { Class.new(Jat) { plugin(:_activerecord_preloads) } }
+  let(:preloader) { Jat::Plugins::ActiverecordPreloads::Preloader }
+
+  describe "InstanceMethods" do
+    it "adds preloads to object in initialize call" do
+      obj = "OBJ"
+      preloads = "PRELOADS"
+      jat_class.expects(:jat_preloads).with(kind_of(jat_class)).returns(preloads)
+      preloader.expects(:preload).with(obj, preloads).returns("OBJ_WITH_PRELOADS")
+
+      jat = jat_class.new(obj, {})
+      assert_equal("OBJ_WITH_PRELOADS", jat.object)
+    end
+
+    it "skips preloadings for nil" do
+      object = nil
+      jat = jat_class.new(object, {})
+      assert_same object, jat.object
+    end
+
+    it "skips preloadings for empty array" do
+      object = []
+      jat = jat_class.new(object, {})
+      assert_same object, jat.object
+    end
+
+    it "skips preloadings when nothing to preload" do
+      object = "OBJECT"
+      jat_class.expects(:jat_preloads).with(kind_of(jat_class)).returns({})
+
+      jat = jat_class.new(object, {})
+      assert_same object, jat.object
+    end
+  end
+end

data/test/lib/jat/plugins/_activerecord_preloads/lib/preloader_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "support/activerecord"
+
+describe "Jat::Plugins::ActiverecordPreloads" do
+  before { Jat::Plugins.load_plugin(:_activerecord_preloads) }
+
+  describe "Preloader" do
+    let(:described_class) { plugin::Preloader }
+    let(:plugin) { Jat::Plugins::ActiverecordPreloads }
+
+    describe ".handlers" do
+      it "returns memorized array of handlers" do
+        assert_equal [
+          plugin::ActiverecordRelation,
+          plugin::ActiverecordObject,
+          plugin::ActiverecordArray
+        ], described_class.handlers
+
+        assert_same described_class.handlers, described_class.handlers
+      end
+    end
+
+    describe ".preload" do
+      it "raises error when can't find appropriate handler" do
+        preloads = {}
+
+        object = nil
+        err = assert_raises(Jat::Error) { described_class.preload(object, {}) }
+        assert_equal "Can't preload #{preloads.inspect} to #{object.inspect}", err.message
+
+        object = []
+        err = assert_raises(Jat::Error) { described_class.preload(object, {}) }
+        assert_equal "Can't preload #{preloads.inspect} to #{object.inspect}", err.message
+
+        object = 123
+        err = assert_raises(Jat::Error) { described_class.preload(object, {}) }
+        assert_equal "Can't preload #{preloads.inspect} to #{object.inspect}", err.message
+
+        object = [AR::User.create!, AR::Comment.create!]
+        err = assert_raises(Jat::Error) { described_class.preload(object, {}) }
+        assert_equal "Can't preload #{preloads.inspect} to #{object.inspect}", err.message
+      end
+
+      it "preloads data to activerecord object" do
+        user = AR::User.create!
+
+        result = described_class.preload(user, {comments: {}})
+
+        assert_same result, user
+        assert_equal true, user.association(:comments).loaded?
+      end
+
+      it "resets activerecord object preloaded relations" do
+        user = AR::User.create!
+        comment = user.comments.create!
+        user.comments.to_a && comment.delete # preload comments manually and delete comment
+
+        described_class.preload(user, {comments: {}})
+
+        assert_equal true, user.association(:comments).loaded?
+        assert_equal [], user.comments
+      end
+
+      it "preloads data to activerecord relation object" do
+        user = AR::User.create!
+
+        result = described_class.preload(AR::User.where(id: user.id), {comments: {}})
+
+        assert_equal result, [user]
+        assert_equal true, result[0].association(:comments).loaded?
+      end
+
+      it "preloads data to activerecord array" do
+        user = AR::User.create!
+
+        users = [user]
+        result = described_class.preload(users, {comments: {}})
+
+        assert_same result, users
+        assert_equal true, result[0].association(:comments).loaded?
+      end
+
+      it "resets activerecord array preloaded relations" do
+        user = AR::User.create!
+        comment = user.comments.create!
+        user.comments.to_a && comment.delete # preload comments manually and delete comment
+
+        users = [user]
+        result = described_class.preload(users, {comments: {}})
+
+        assert_equal true, result[0].association(:comments).loaded?
+        assert_equal [], result[0].comments
+      end
+    end
+  end
+end

data/test/lib/jat/plugins/_json_api_activerecord/_json_api_activerecord_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApiActiverecord" do
+  before do
+    @plugin = Jat::Plugins.load_plugin(:_json_api_activerecord)
+  end
+
+  it "loads other plugins in after_load" do
+    jat_class = Class.new(Jat)
+    jat_class.expects(:plugin).with(:_preloads, foo: :bar)
+    jat_class.expects(:plugin).with(:_activerecord_preloads, foo: :bar)
+
+    Jat::Plugins.after_load(@plugin, jat_class, foo: :bar)
+  end
+
+  describe "ClassMethods" do
+    it "add .jat_preloads method as a delegator to #{@plugin}::Preloads" do
+      jat_class = Class.new(Jat)
+      jat_class.plugin @plugin
+      jat = jat_class.allocate
+
+      @plugin::Preloads.expects(:call).with(jat).returns("RES")
+
+      assert_equal "RES", jat_class.jat_preloads(jat)
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApiActiverecord::Preloads" do
+  let(:base) { Class.new(Jat) { plugin :json_api, activerecord: true } }
+
+  let(:user_serializer) { Class.new(base) { type(:user) } }
+  let(:profile_serializer) { Class.new(base) { type(:profile) } }
+  let(:email_serializer) { Class.new(base) { type(:email) } }
+
+  let(:jat_user) { user_serializer.allocate }
+  let(:jat_profile) { profile_serializer.allocate }
+  let(:jat_email) { email_serializer.allocate }
+
+  let(:described_class) { Jat::Plugins::JsonApiActiverecord::Preloads }
+
+  def define_map(map)
+    jat_user.traversal_map.expects(:current).returns(map)
+  end
+
+  it "returns empty hash when no attributes requested" do
+    define_map(user: {attributes: [], relationships: []})
+
+    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(user: {attributes: [:name], relationships: []})
+
+    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(user: {attributes: [:name], relationships: []})
+
+    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(user: {attributes: %i[first_name phone email], relationships: []})
+
+    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(
+      user: {attributes: [], relationships: %i[profile]},
+      profile: {attributes: %i[email], relationships: []}
+    )
+
+    result = described_class.call(jat_user)
+    assert_equal({}, result)
+  end
+
+  it "returns preloads for nested relationships joined to root when specified preloads is {} or []" do
+    [{}, []].each do |preloads|
+      user_serializer.relationship :profile, serializer: profile_serializer, preload: preloads
+      profile_serializer.attribute :email, preload: :email # should be preloaded to root
+      define_map(
+        user: {attributes: [], relationships: %i[profile]},
+        profile: {attributes: %i[email], relationships: []}
+      )
+
+      result = described_class.call(jat_user)
+      assert_equal({email: {}}, result)
+    end
+  end
+
+  it "returns preloads for relationships" do
+    user_serializer.relationship :profile, serializer: profile_serializer
+    define_map(
+      user: {attributes: [], relationships: %i[profile]},
+      profile: {attributes: [], relationships: []}
+    )
+
+    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(
+      user: {attributes: [], relationships: %i[profile]},
+      profile: {attributes: %i[email], relationships: []}
+    )
+
+    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(
+      user: {attributes: [], relationships: %i[profile]},
+      profile: {attributes: %i[email], relationships: []}
+    )
+
+    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(
+      user: {attributes: [], relationships: %i[profile]},
+      profile: {attributes: %i[email], relationships: []}
+    )
+
+    result = described_class.call(jat_user)
+    assert_equal({company: {profile: {}, confirmed_email: {}, unconfirmed_email: {}}}, result)
+  end
+
+  it "raises error if with 2 serializers have recursive preloads" do
+    user_serializer.relationship :profile, serializer: profile_serializer, preload: :profile
+    profile_serializer.relationship :user, serializer: user_serializer, preload: :user
+
+    define_map(
+      user: {attributes: [], relationships: %i[profile]},
+      profile: {attributes: [], relationships: %i[user]}
+    )
+
+    error = assert_raises(Jat::Error) { described_class.call(jat_user) }
+    assert_match(/recursive preloads/, error.message)
+  end
+
+  it "raises error if 3 serializers recursive preloads" do
+    user_serializer.relationship :profile, serializer: profile_serializer, preload: :profile
+    profile_serializer.relationship :email, serializer: email_serializer, preload: :email
+    email_serializer.relationship :user, serializer: user_serializer, preload: :user
+
+    define_map(
+      user: {attributes: [], relationships: %i[profile]},
+      profile: {attributes: [], relationships: %i[email]},
+      email: {attributes: [], relationships: %i[user]}
+    )
+
+    error = assert_raises(Jat::Error) { described_class.call(jat_user) }
+    assert_match(/recursive preloads/, error.message)
+  end
+
+  it "does not raises error if 2 serializers preloads same preloads" do
+    user_serializer.relationship :profile, serializer: profile_serializer, preload: :profile
+    user_serializer.relationship :email, serializer: email_serializer, preload: :email
+    profile_serializer.relationship :email, serializer: email_serializer, preload: :email
+
+    define_map(
+      user: {attributes: [], relationships: %i[profile email]},
+      profile: {attributes: [], relationships: %i[email]},
+      email: {attributes: [], relationships: %i[]}
+    )
+
+    described_class.call(jat_user) # should not raise
+  end
+
+  it "merges preloads the same way regardless of order of preloads" do
+    a = Class.new(base) { type(:a) }
+    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.traversal_map.expects(:current).returns(a: {attributes: %i[a1 a2], relationships: %i[]})
+    jat_a2.traversal_map.expects(:current).returns(a: {attributes: %i[a2 a1], relationships: %i[]})
+
+    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

data/test/lib/jat/plugins/_preloads/_preloads_test.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::Preloads" do
+  let(:jat_class) do
+    Class.new(Jat) { plugin(:_preloads) }
+  end
+
+  def attribute(name, opts)
+    jat_class.attribute(name, **opts)
+  end
+
+  describe "AttributeMethods" do
+    it "saves @preloads and @preloads_path after first access" do
+      attribute = attribute(:foo, preload: :bar)
+
+      assert_same attribute.preloads, attribute.preloads
+      assert_same attribute.preloads_path, attribute.preloads_path
+    end
+
+    describe "#preloads" do
+      it "returns formatted data provided by user" do
+        assert_equal({}, attribute(:foo, preload: {}).preloads)
+        assert_equal({}, attribute(:foo, preload: []).preloads)
+        assert_equal({some: {}}, attribute(:foo, preload: :some).preloads)
+        assert_equal({some: {data: {}}}, attribute(:foo, preload: {some: :data}).preloads)
+      end
+
+      it "preloads main key when serializer exists and preloads are not" do
+        assert_equal({foo: {}}, attribute(:foo, serializer: jat_class).preloads)
+        assert_equal({bar: {}}, attribute(:foo, key: :bar, serializer: jat_class).preloads)
+      end
+
+      it "returns nil when requested to preload nil or false" do
+        assert_nil attribute(:foo, serializer: jat_class, preload: nil).preloads
+        assert_nil attribute(:foo, key: :bar, serializer: jat_class, preload: false).preloads
+      end
+
+      it "removes bang (!) from preloads" do
+        assert_equal({foo: {}}, attribute(:foo, preload: :foo!).preloads)
+      end
+    end
+
+    describe "#preloads_path" do
+      it "returns path to main resource provided by user" do
+        assert_equal([], attribute(:foo, preload: nil).preloads_path)
+        assert_equal([], attribute(:foo, preload: {}).preloads_path)
+        assert_equal([], attribute(:foo, preload: []).preloads_path)
+        assert_equal([:some], attribute(:foo, preload: :some).preloads_path)
+        assert_equal(%i[some data], attribute(:foo, preload: {some: :data}).preloads_path)
+      end
+
+      it "show path to main key when serializer exists and preloads are not" do
+        assert_equal([:foo], attribute(:foo, serializer: jat_class).preloads_path)
+        assert_equal([:bar], attribute(:foo, key: :bar, serializer: jat_class).preloads_path)
+
+        # serializer with empty preloads provided
+        assert_equal([], attribute(:foo, serializer: jat_class, preload: nil).preloads_path)
+        assert_equal([], attribute(:foo, key: :bar, serializer: jat_class, preload: false).preloads_path)
+      end
+
+      it "removes bang (!) and construct path to this preload" do
+        assert_equal([:some], attribute(:foo, preload: {some!: :data}).preloads_path)
+      end
+    end
+  end
+end

data/test/lib/jat/plugins/_preloads/lib/format_user_preloads_test.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::Preloads::FormatUserPreloads" do
+  before { Jat::Plugins.load_plugin(:_preloads) }
+
+  let(:format) { Jat::Plugins::Preloads::FormatUserPreloads }
+
+  it "transforms nil to empty hash" do
+    preloads = nil
+    assert_equal ({}), format.to_hash(preloads)
+  end
+
+  it "transforms false to empty hash" do
+    preloads = false
+    assert_equal({}, format.to_hash(preloads))
+  end
+
+  it "transforms Symbol" do
+    preloads = :foo
+    assert_equal({foo: {}}, format.to_hash(preloads))
+  end
+
+  it "transforms String" do
+    preloads = "foo"
+    assert_equal({foo: {}}, format.to_hash(preloads))
+  end
+
+  it "transforms Hash" do
+    preloads = {foo: :bar}
+    assert_equal({foo: {bar: {}}}, format.to_hash(preloads))
+  end
+
+  it "transforms Array" do
+    preloads = %i[foo bar]
+    assert_equal({foo: {}, bar: {}}, format.to_hash(preloads))
+  end
+
+  it "transforms nested hashes and arrays" do
+    preloads = [:foo, {"bar" => "bazz"}, ["bazz"]]
+    assert_equal({foo: {}, bar: {bazz: {}}, bazz: {}}, format.to_hash(preloads))
+
+    preloads = {"bar" => "bazz", :foo => [:bar, "bazz"]}
+    assert_equal({bar: {bazz: {}}, foo: {bar: {}, bazz: {}}}, format.to_hash(preloads))
+  end
+end