jat 0.0.3 → 0.0.8

data/test/lib/jat/plugins/simple_api_maps_cache/simple_api_maps_cache_test.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApiMapsCache" do
+  before do
+    @plugin = Jat::Plugins.find_plugin(:simple_api_maps_cache)
+  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 "adds config variable how many maps to store per serializer" do
+    jat_class = Class.new(Jat)
+
+    @plugin.after_load(jat_class)
+    assert_equal(100, jat_class.config[:cached_maps_count]) # default 100
+
+    @plugin.after_load(jat_class, cached_maps_count: 10) # change value via opts
+    assert_equal(10, jat_class.config[:cached_maps_count])
+  end
+
+  describe "Test maps responses" do
+    let(:jat_class) do
+      Class.new(Jat) do
+        plugin(:simple_api)
+        plugin(:simple_api_maps_cache)
+
+        attribute(:attr1)
+        attribute(:attr2)
+      end
+    end
+
+    it "returns same maps when requested with same params" do
+      full_map1 = jat_class::Map.call(exposed: :all)
+      full_map2 = jat_class::Map.call(exposed: :all)
+
+      exposed_map1 = jat_class::Map.call(exposed: :default)
+      exposed_map2 = jat_class::Map.call(exposed: :default)
+
+      current_map1 = jat_class::Map.call(fields: "attr1")
+      current_map2 = jat_class::Map.call(fields: "attr1")
+      current_map3 = jat_class::Map.call(fields: "attr2")
+
+      assert_same(full_map1, full_map2)
+      assert_same(exposed_map1, exposed_map2)
+      assert_same(current_map1, current_map2)
+
+      # should not match, fields are not same
+      assert !current_map1.equal?(current_map3)
+    end
+
+    it "stores different maps keys" do
+      # key 1
+      jat_class::Map.call(exposed: :all)
+      jat_class::Map.call(exposed: :all)
+
+      # key 2
+      jat_class::Map.call(exposed: :default)
+      jat_class::Map.call(exposed: :default)
+
+      # key 3
+      jat_class::Map.call(fields: "attr1")
+      jat_class::Map.call(fields: "attr1")
+
+      # key 4
+      jat_class::Map.call(fields: "attr2")
+
+      # key 5
+      jat_class::Map.call(fields: "attr1,attr2")
+
+      assert_equal 5, jat_class::Map.maps_cache.keys.count
+    end
+
+    it "clears old results when there are too many cache keys" do
+      jat_class.config[:cached_maps_count] = 1
+
+      full_map1 = jat_class::Map.call(exposed: :all)
+      full_map2 = jat_class::Map.call(exposed: :all)
+
+      # ensure maps refer to same object
+      assert_same(full_map1, full_map2)
+
+      # replace single possible cache key with another `exposed` map
+      jat_class::Map.call(exposed: :default)
+
+      # calculate full map again, it should not match
+      full_map3 = jat_class::Map.call(exposed: :all)
+      assert !full_map1.equal?(full_map3)
+    end
+  end
+end

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,51 @@
+# 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(:base_preloads, foo: :bar)
+
+    @plugin.before_load(jat_class, foo: :bar)
+  end
+
+  describe "InstanceMethods" do
+    it "adds #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
+
+  describe "ClassMethods" do
+    it "adds .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
+      jat_class.expects(:new).with("CONTEXT").returns(jat)
+      @plugin::Preloads.expects(:call).with(jat).returns("RES")
+
+      assert_equal "RES", jat_class.preloads("CONTEXT")
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# 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 "returns true when provided fields present" do
+    jat = serializer.new(fields: "foo_bar,foo_bazz(foo_bar)")
+    assert jat.validate
+  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 fields when using lower_camel_case plugin" do
+    jat = serializer_lower_camel_case.new(fields: "fooBar,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

@@ -7,7 +7,7 @@ describe "Jat::Plugins::ToStr" do
     new_class = Class.new(Jat)
     new_class.plugin(:to_str)
     new_class.class_exec do
-      def to_h
+      def to_h(object)
         {object => context}
       end
     end
@@ -34,7 +34,7 @@ describe "Jat::Plugins::ToStr" do
         new_class = Class.new(Jat)
         new_class.plugin(:to_str, to_str: ->(data) { data.inspect })
         new_class.class_exec do
-          def to_h
+          def to_h(object)
             {object => context}
           end
         end
@@ -45,7 +45,7 @@ describe "Jat::Plugins::ToStr" do
 
     describe "#to_str" do
       it "returns json string of to_h" do
-        assert_equal '{"obj":"ctx"}', jat_class.new("obj", "ctx").to_str
+        assert_equal '{"obj":"ctx"}', jat_class.new("ctx").to_str("obj")
       end
     end
   end

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

@@ -0,0 +1,84 @@
+# 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
+
+  it "allows to skip type" do
+    jat_class.attribute(:attr)
+    assert_equal(333, attr_value(333))
+  end
+end

data/test/lib/jat/plugins/validate_params/validate_params_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::ValidateParams" do
+  it "raises error if no response plugin is loaded" do
+    new_class = Class.new(Jat)
+    err = assert_raises(Jat::Error) { new_class.plugin :validate_params }
+    assert_equal "Please load :json_api or :simple_api plugin first", err.message
+  end
+
+  it "loads simple_api compatible plugin" do
+    new_class = Class.new(Jat)
+    new_class.plugin :simple_api
+    new_class.plugin :validate_params
+
+    assert new_class.plugin_used?(:simple_api_validate_params)
+  end
+
+  it "loads json_api compatible plugin" do
+    new_class = Class.new(Jat)
+    new_class.plugin :json_api
+    new_class.plugin :validate_params
+
+    assert new_class.plugin_used?(:json_api_validate_params)
+  end
+end

data/test/lib/jat/plugins_test.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat::Plugins do
+  let(:described_module) { Jat::Plugins }
+
+  describe ".register_plugin" do
+    it "adds plugin to the @plugins list" do
+      plugin = Module.new
+      plugin_name = :new_plugin
+      described_module.register_plugin(plugin_name, plugin)
+
+      assert_equal plugin, described_module.instance_variable_get(:@plugins).fetch(plugin_name)
+    end
+  end
+
+  describe ".find_plugin" do
+    it "returns module if module provided" do
+      plugin = Module.new
+      assert_equal plugin, described_module.find_plugin(plugin)
+    end
+
+    it "returns already registered plugin found by name" do
+      plugin = Module.new
+      plugin_name = :new_plugin
+      described_module.register_plugin(plugin_name, plugin)
+
+      assert_equal plugin, described_module.find_plugin(plugin_name)
+    end
+
+    it "returns global plugins found by name" do
+      assert_equal "Jat::Plugins::Activerecord", described_module.find_plugin(:activerecord).name
+      assert_equal "Jat::Plugins::Cache", described_module.find_plugin(:cache).name
+      assert_equal "Jat::Plugins::JsonApi", described_module.find_plugin(:json_api).name
+      assert_equal "Jat::Plugins::LowerCamelCase", described_module.find_plugin(:lower_camel_case).name
+      assert_equal "Jat::Plugins::MapsCache", described_module.find_plugin(:maps_cache).name
+      assert_equal "Jat::Plugins::Preloads", described_module.find_plugin(:preloads).name
+      assert_equal "Jat::Plugins::SimpleApi", described_module.find_plugin(:simple_api).name
+      assert_equal "Jat::Plugins::ToStr", described_module.find_plugin(:to_str).name
+      assert_equal "Jat::Plugins::Types", described_module.find_plugin(:types).name
+      assert_equal "Jat::Plugins::ValidateParams", described_module.find_plugin(:validate_params).name
+    end
+
+    it "returns json_api only plugins found by name (name has `json_api_` prefix)" do
+      assert_equal "Jat::Plugins::JsonApiActiverecord", described_module.find_plugin(:json_api_activerecord).name
+      assert_equal "Jat::Plugins::JsonApiLowerCamelCase", described_module.find_plugin(:json_api_lower_camel_case).name
+      assert_equal "Jat::Plugins::JsonApiMapsCache", described_module.find_plugin(:json_api_maps_cache).name
+      assert_equal "Jat::Plugins::JsonApiPreloads", described_module.find_plugin(:json_api_preloads).name
+      assert_equal "Jat::Plugins::JsonApiValidateParams", described_module.find_plugin(:json_api_validate_params).name
+    end
+
+    it "returns simple_api only plugins found by name (name has `simple_api_` prefix)" do
+      assert_equal "Jat::Plugins::SimpleApiActiverecord", described_module.find_plugin(:simple_api_activerecord).name
+      assert_equal "Jat::Plugins::SimpleApiLowerCamelCase", described_module.find_plugin(:simple_api_lower_camel_case).name
+      assert_equal "Jat::Plugins::SimpleApiMapsCache", described_module.find_plugin(:simple_api_maps_cache).name
+      assert_equal "Jat::Plugins::SimpleApiPreloads", described_module.find_plugin(:simple_api_preloads).name
+      assert_equal "Jat::Plugins::SimpleApiValidateParams", described_module.find_plugin(:simple_api_validate_params).name
+    end
+
+    it "returns base plugins found by name (name has `base_` prefix)" do
+      assert_equal "Jat::Plugins::BaseActiverecordPreloads", described_module.find_plugin(:base_activerecord_preloads).name
+      assert_equal "Jat::Plugins::BaseLowerCamelCase", described_module.find_plugin(:base_lower_camel_case).name
+      assert_equal "Jat::Plugins::BasePreloads", described_module.find_plugin(:base_preloads).name
+    end
+
+    it "raises specific error if plugin not found" do
+      err = assert_raises(Jat::PluginLoadError) { described_module.find_plugin(:foo) }
+      assert_equal "Plugin 'foo' does not exist", err.message
+    end
+
+    it "raises specific error if plugin was found by name but was not registered" do
+      plugin_name = "test_foo"
+
+      # Add plugin folder and file in plugins directory
+      plugin_dir = File.join(__dir__, "../../../lib/jat/plugins", plugin_name)
+      plugin_path = File.join(plugin_dir, "#{plugin_name}.rb")
+      Dir.mkdir(plugin_dir)
+      File.new(plugin_path, File::CREAT)
+
+      err = assert_raises(Jat::PluginLoadError) { described_module.find_plugin(plugin_name) }
+      assert_equal "Plugin '#{plugin_name}' did not register itself correctly", err.message
+    ensure
+      File.unlink(plugin_path)
+      Dir.unlink(plugin_dir)
+    end
+  end
+end