jat 0.0.1 → 0.0.7

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApiPreloads::Preloads" do
+  let(:base) do
+    Class.new(Jat) do
+      plugin :simple_api
+      plugin :simple_api_preloads
+    end
+  end
+
+  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::SimpleApiPreloads::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

data/test/lib/jat/plugins/simple_api_preloads/simple_api_preloads_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApiPreloads" do
+  before do
+    @plugin = Jat::Plugins.find_plugin(:simple_api_preloads)
+  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 in before_load" do
+    jat_class = Class.new(Jat)
+    jat_class.plugin :simple_api
+
+    jat_class.expects(:plugin).with(:_preloads, foo: :bar)
+
+    @plugin.before_load(jat_class, foo: :bar)
+  end
+
+  describe "InstanceMethods" do
+    it "add .preloads method as a delegator to #{@plugin}::Preloads" do
+      jat_class = Class.new(Jat)
+      jat_class.plugin :simple_api
+      jat_class.plugin @plugin
+      jat = jat_class.allocate
+
+      @plugin::Preloads.expects(:call).with(jat).returns("RES")
+
+      assert_equal "RES", jat.preloads
+    end
+  end
+end

data/test/lib/jat/plugins/simple_api_validate_params/simple_api_validate_params_test.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApiValidateParams" do
+  before do
+    @plugin = Jat::Plugins.find_plugin(:simple_api_validate_params)
+  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
+
+  let(:base_serializer) do
+    jat_class = Class.new(Jat)
+    jat_class.plugin :simple_api
+    jat_class.plugin @plugin
+    jat_class
+  end
+
+  let(:serializer) do
+    jat_class = Class.new(base_serializer)
+    jat_class.attribute :foo_bar
+    jat_class.relationship :foo_bazz, serializer: jat_class
+    jat_class
+  end
+
+  let(:serializer_lower_camel_case) do
+    jat_class = Class.new(base_serializer)
+    jat_class.plugin :lower_camel_case
+
+    jat_class.attribute :foo_bar
+    jat_class.relationship :foo_bazz, serializer: jat_class
+    jat_class
+  end
+
+  it "validates fields" do
+    jat = serializer.new(fields: "foo_bar,extra")
+    error = assert_raises(Jat::SimpleApiFieldsError) { jat.validate }
+    expected_message = "Field 'extra' not exists"
+    assert_equal(expected_message, error.message)
+  end
+
+  it "validates deeply nested fields" do
+    c = Class.new(base_serializer)
+    c.attribute :c1
+    c.attribute :c2
+
+    b = Class.new(base_serializer)
+    b.attribute :b1
+    b.attribute :b2
+    b.relationship :c, serializer: c
+
+    a = Class.new(base_serializer)
+    a.attribute :a1
+    a.attribute :a2
+    a.relationship :b, serializer: b
+    a.relationship :c, serializer: c
+
+    jat = a.new(fields: "a1,a2,c(c1,c2),b(b1,b2,c(c1,c2,c3)")
+    error = assert_raises(Jat::SimpleApiFieldsError) { jat.validate }
+    expected_message = "Field 'c3' ('b.c.c3') not exists"
+    assert_equal(expected_message, error.message)
+  end
+
+  it "validates deeply nested fields about not existing relationship" do
+    c = Class.new(base_serializer)
+    c.attribute :c1
+    c.attribute :c2
+
+    b = Class.new(base_serializer)
+    b.attribute :b1
+    b.attribute :b2
+    b.relationship :c, serializer: c
+
+    a = Class.new(base_serializer)
+    a.attribute :a1
+    a.attribute :a2
+    a.relationship :b, serializer: b
+    a.relationship :c, serializer: c
+
+    jat = a.new(fields: "a1,a2,c(c1,c2),b(b1,b2,c(c1,c2(c3))")
+    error = assert_raises(Jat::SimpleApiFieldsError) { jat.validate }
+    expected_message = "Field 'c2' ('b.c.c2') is not a relationship to add 'c3' attribute"
+    assert_equal(expected_message, error.message)
+  end
+end

data/test/lib/jat/plugins/to_str/to_str_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::ToStr" do
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.plugin(:to_str)
+    new_class.class_exec do
+      def to_h(object)
+        {object => context}
+      end
+    end
+
+    new_class
+  end
+
+  describe "Jat" do
+    describe ".to_str" do
+      it "returns json string of to_h" do
+        assert_equal '{"obj":"ctx"}', jat_class.to_str("obj", "ctx")
+      end
+
+      it "returns json string of to_h with default empty hash context" do
+        assert_equal '{"obj":{}}', jat_class.to_str("obj")
+      end
+
+      it "returns result serialized with given in config serializer" do
+        jat_class.config[:to_str] = ->(data) { data.inspect }
+        assert_equal '{"obj"=>"ctx"}', jat_class.to_str("obj", "ctx")
+      end
+
+      it "accepts to_str config option when loading plugin" do
+        new_class = Class.new(Jat)
+        new_class.plugin(:to_str, to_str: ->(data) { data.inspect })
+        new_class.class_exec do
+          def to_h(object)
+            {object => context}
+          end
+        end
+
+        assert_equal '{"obj"=>"ctx"}', new_class.to_str("obj", "ctx")
+      end
+    end
+
+    describe "#to_str" do
+      it "returns json string of to_h" do
+        assert_equal '{"obj":"ctx"}', jat_class.new("ctx").to_str("obj")
+      end
+    end
+  end
+end

data/test/lib/jat/plugins/types/types_test.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::Types" do
+  let(:struct) { Struct.new(:attr) }
+  let(:obj) { struct.new(nil) }
+
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.plugin(:types)
+    new_class
+  end
+
+  def attr_value(original_value)
+    obj = struct.new(original_value)
+    jat_class.attributes[:attr].value(obj, nil)
+  end
+
+  it "has predefined :int type" do
+    jat_class.attribute(:attr, type: :int)
+
+    assert_equal(0, attr_value("0"))
+    assert_equal(8, attr_value("010")) # octal system
+    assert_equal(10, attr_value("0xa")) # hexadecimal system
+  end
+
+  it "has predefined :bool type" do
+    jat_class.attribute(:attr, type: :bool)
+
+    assert_equal(false, attr_value(nil))
+    assert_equal(false, attr_value(false))
+    assert_equal(true, attr_value(1))
+  end
+
+  it "has predefined :float type" do
+    jat_class.attribute(:attr, type: :float)
+
+    assert_same(0.0, attr_value("0"))
+    assert_same(0.001, attr_value("1e-3"))
+    assert_same(1.234, attr_value("1.234"))
+  end
+
+  it "has predefined :array type" do
+    jat_class.attribute(:attr, type: :array)
+
+    assert_equal([1], attr_value(1))
+    assert_equal([1], attr_value([1]))
+  end
+
+  it "has predefined :hash type" do
+    jat_class.attribute(:attr, type: :hash)
+
+    assert_equal({}, attr_value([]))
+    assert_equal({}, attr_value({}))
+    assert_equal({key: :value}, attr_value(key: :value))
+  end
+
+  it "has predefined :str type" do
+    jat_class.attribute(:attr, type: :str)
+
+    assert_equal("", attr_value(nil))
+    assert_equal("123", attr_value(123))
+  end
+
+  it "allows to use callable method as type" do
+    jat_class.attribute(:attr, type: ->(obj) { obj ? :yes : :no })
+
+    assert_equal(:no, attr_value(nil))
+    assert_equal(:yes, attr_value(1))
+  end
+
+  it "allows to configure custom type" do
+    jat_class.config[:types][:year] = ->(obj) { obj.strftime("%Y") }
+    jat_class.attribute(:attr, type: :year)
+
+    assert_equal("2020", attr_value(Time.new(2020, 10, 10)))
+  end
+end

data/test/lib/jat/utils/enum_deep_dup_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat::EnumDeepDup do
+  describe ".call" do
+    it "makes deep dup of hash" do
+      hash = {key1: {key11: {key111: :value111}}, key2: [{key22: {key222: :value222}}]}
+      dup = Jat::EnumDeepDup.call(hash)
+
+      assert_equal hash, dup
+
+      refute_same hash, dup
+      refute_same hash[:key1], dup[:key1]
+      refute_same hash[:key1][:key11], dup[:key1][:key11]
+
+      refute_same hash[:key2], dup[:key2]
+      refute_same hash[:key2][0], dup[:key2][0]
+      refute_same hash[:key2][0][:key22], dup[:key2][0][:key22]
+    end
+
+    it "does not duplicates non-enumerable objects" do
+      hash = {key1: Jat, key2: [-> {}]}
+      dup = Jat::EnumDeepDup.call(hash)
+
+      assert_equal hash, dup
+      assert_same hash[:key1], dup[:key1]
+      assert_same hash[:key2][0], dup[:key2][0]
+    end
+  end
+end

data/test/lib/jat/utils/enum_deep_freeze_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat::EnumDeepFreeze do
+  describe ".call" do
+    it "deeply freezes provided hash" do
+      hash = {key1: {key11: {key111: :value111}}, key2: [{key22: {key222: :value222}}]}
+      Jat::EnumDeepFreeze.call(hash)
+
+      assert hash.frozen?
+      assert hash[:key1].frozen?
+      assert hash[:key1][:key11].frozen?
+
+      assert hash[:key2].frozen?
+      assert hash[:key2][0].frozen?
+      assert hash[:key2][0][:key22].frozen?
+    end
+
+    it "does not freezes non-enumerable objects" do
+      hash = {key1: Jat, key2: [-> {}]}
+      Jat::EnumDeepFreeze.call(hash)
+
+      refute hash[:key1].frozen?
+      refute hash[:key2][0].frozen?
+    end
+  end
+end

data/test/lib/jat_test.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat do
+  let(:jat_class) { Class.new(Jat) }
+
+  describe ".plugin" do
+    it "loads same plugin only once" do
+      plugin = Module.new
+      jat_class.plugin plugin
+      jat_class.plugin plugin
+
+      assert_equal [plugin], jat_class.config[:plugins]
+    end
+  end
+
+  describe ".plugin_used?" do
+    it "tells if plugin has been already used in current serializer" do
+      assert_equal false, jat_class.plugin_used?(:json_api)
+      jat_class.plugin(:json_api)
+      assert_equal true, jat_class.plugin_used?(:json_api)
+    end
+
+    it "accepts Module" do
+      plugin = Module.new
+
+      assert_equal false, jat_class.plugin_used?(plugin)
+      jat_class.plugin(plugin)
+      assert_equal true, jat_class.plugin_used?(plugin)
+    end
+  end
+
+  describe ".config" do
+    it "returns config object with default values" do
+      config = jat_class.config
+      assert_equal jat_class::Config, config.class
+      assert_equal({plugins: []}, config.opts)
+    end
+  end
+
+  describe ".inherited" do
+    let(:parent) { jat_class }
+
+    it "inherits config class with same options" do
+      parent.config[:foo] = :bar
+      child = Class.new(parent)
+
+      assert_equal parent::Config, child::Config.superclass
+      assert_equal :bar, child.config[:foo]
+    end
+
+    it "inherits attributes" do
+      parent.attribute(:foo) { :bar }
+      child = Class.new(parent)
+
+      assert_equal parent::Attribute, child::Attribute.superclass
+      assert child.attributes[:foo]
+    end
+  end
+
+  describe ".call" do
+    it "returns self" do
+      assert_equal jat_class, jat_class.call
+    end
+  end
+
+  describe ".to_h" do
+    let(:jat) { jat_class.allocate }
+
+    it "raises error that we should add some response generation plugin" do
+      error = assert_raises(Jat::Error) { jat_class.to_h(nil) }
+
+      error_message = "Method #to_h must be implemented by plugin"
+      assert_equal error_message, error.message
+    end
+
+    it "initializes serializer instance with provided context" do
+      jat.expects(:to_h).with("obj")
+      jat_class.expects(:new).with("context").returns(jat)
+      jat_class.to_h("obj", "context")
+    end
+
+    it "adds empty hash context when context not provided" do
+      jat.expects(:to_h).with("obj")
+      jat_class.expects(:new).with({}).returns(jat)
+      jat_class.to_h("obj")
+    end
+  end
+
+  describe ".attributes" do
+    it "initializes new attributes hash" do
+      assert_equal({}, jat_class.attributes)
+      assert_same jat_class.attributes, jat_class.instance_variable_get(:@attributes)
+    end
+  end
+
+  describe ".attribute" do
+    it "adds new attribute to attributes hash" do
+      attribute = jat_class.attribute :foo
+      assert_equal jat_class.attributes[:foo], attribute
+    end
+  end
+
+  describe ".relationship" do
+    it "forces using of :serializer option" do
+      error = assert_raises(ArgumentError) { jat_class.relationship(:foo) }
+      assert_match "serializer", error.message
+    end
+
+    it "adds new attribute" do
+      jat_class.relationship(:foo, serializer: jat_class)
+
+      attribute = jat_class.attributes[:foo]
+      assert_equal jat_class, attribute.serializer
+    end
+  end
+
+  describe "#initialize" do
+    it "initializes context" do
+      jat = jat_class.new("context")
+      assert_equal "context", jat.context
+    end
+  end
+
+  describe "#to_h" do
+    it "raises error" do
+      jat = jat_class.new
+
+      error = assert_raises(Jat::Error) { jat.to_h(nil) }
+      error_message = "Method #to_h must be implemented by plugin"
+      assert_equal error_message, error.message
+    end
+  end
+
+  describe "#config" do
+    it "returns self class config" do
+      jat = jat_class.new
+
+      assert_same jat.config, jat_class.config
+    end
+  end
+end

data/test/lib/plugin_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "test_plugin"
+
+describe "plugin system" do
+  describe "Jat.plugin" do
+    let(:jat_class) { Class.new(Jat) }
+    let(:components) { [jat_class, jat_class::Attribute, jat_class::Config] }
+
+    before do
+      components.each do |component|
+        component::InstanceMethods.send(:define_method, :foo) { :foo }
+        component::ClassMethods.send(:define_method, :foo) { :foo }
+      end
+    end
+
+    after do
+      components.each do |component|
+        component::InstanceMethods.send(:undef_method, :foo)
+        component::ClassMethods.send(:undef_method, :foo)
+      end
+    end
+
+    it "allows the plugin to override base methods of core classes" do
+      components.each do |component|
+        assert_equal :foo, component.foo
+        assert_equal :foo, component.allocate.foo
+      end
+
+      jat_class.plugin(TestPlugin)
+
+      components.each do |component|
+        assert_equal :plugin_foo, component.foo
+        assert_equal :plugin_foo, component.allocate.foo
+      end
+    end
+
+    it "calls before_load before loading plugin" do
+      jat_class.plugin(TestPlugin)
+      assert_equal :foo, jat_class.config[:before_load]
+    end
+
+    it "calls after_load after loading plugin" do
+      jat_class.plugin(TestPlugin)
+      assert_equal :plugin_foo, jat_class.config[:after_load]
+    end
+  end
+end

data/test/support/activerecord.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+conn = ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:").connection
+
+conn.create_table(:users) do |t|
+  t.string :name
+end
+
+conn.create_table(:comments) do |t|
+  t.belongs_to :user, index: false
+  t.text :text
+end
+
+module AR
+  class User < ActiveRecord::Base
+    has_many :comments
+  end
+
+  class Comment < ActiveRecord::Base
+    belongs_to :user
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+if RUBY_VERSION >= "2.7"
+  Warning[:deprecated] = true
+  Warning[:experimental] = true
+end
+
+require "bundler/setup"
+require "minitest/autorun"
+require "mocha/minitest"
+require "pry-byebug"
+
+require_relative "../lib/jat"