jat 0.0.1 → 0.0.7

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

@@ -0,0 +1,348 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApi::Response" do
+  let(:base_class) { Class.new(Jat) { plugin :simple_api } }
+
+  it "returns empty hash when nothing to serialize" do
+    empty_serializer = Class.new(base_class)
+
+    assert_equal({}, empty_serializer.to_h(nil))
+  end
+
+  it "returns correct structure with data" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal({id: "STRING"}, str_serializer.to_h("STRING"))
+  end
+
+  it "returns correct structure when parameter `many` defined manually" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[:foo] }
+    end
+
+    # By default hash is interpreted as `many: true` as it is Enumerable
+    obj = {foo: :bar}
+    context = {many: false}
+
+    assert_equal({id: :bar}, str_serializer.to_h(obj, context))
+  end
+
+  it "returns correct structure with array data" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal(
+      [{id: "1"}, {id: "2"}],
+      str_serializer.to_h(%w[1 2])
+    )
+  end
+
+  it "returns correct structure with array data" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal(
+      [{id: "1"}, {id: "2"}],
+      str_serializer.to_h(%w[1 2])
+    )
+  end
+
+  it "returns correct structure with one object with root key" do
+    str_serializer = Class.new(base_class) do
+      root(:digit)
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal({digit: {id: "1"}}, str_serializer.to_h("1"))
+  end
+
+  it "returns correct structure with list with root key" do
+    str_serializer = Class.new(base_class) do
+      root(:digits)
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal(
+      {digits: [{id: "1"}, {id: "2"}]},
+      str_serializer.to_h(%w[1 2])
+    )
+  end
+
+  it "returns correct roots" do
+    str_serializer = Class.new(base_class) do
+      root(one: :digit, many: :digits)
+
+      attribute(:id) { |obj| obj }
+    end
+
+    assert_equal({digit: {id: "1"}}, str_serializer.to_h("1"))
+    assert_equal({digits: [{id: "1"}]}, str_serializer.to_h(["1"]))
+  end
+
+  it "returns correct structures when root is overwritten" do
+    str_serializer = Class.new(base_class) do
+      root(: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 multiple attributes" do
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+      attribute :length
+    end
+
+    assert_equal({id: "1", length: 1}, str_serializer.to_h("1"))
+  end
+
+  it "returns correct structure with has-one relationship" do
+    int_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :length, serializer: int_serializer, exposed: true
+    end
+
+    assert_equal({id: "S", length: {id: 6}}, str_serializer.to_h("STRING"))
+  end
+
+  it "returns correct structure when children serializer defined as lambda" do
+    int_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :length, serializer: -> { int_serializer }, exposed: true
+    end
+
+    assert_equal({id: "S", length: {id: 6}}, str_serializer.to_h("STRING"))
+  end
+
+  it "does not return has-one relationship when not exposed" do
+    int_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :length, serializer: int_serializer, exposed: false
+    end
+
+    assert_equal({id: "S"}, str_serializer.to_h("STRING"))
+  end
+
+  it "returns nil as empty has-one relationship" do
+    int_serializer = Class.new(base_class)
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute(:length, serializer: int_serializer, exposed: true) { |_obj| nil }
+    end
+
+    assert_equal(
+      {id: "S", length: nil},
+      str_serializer.to_h("STRING")
+    )
+  end
+
+  it "returns correct structure with has-one relationship with attributes" do
+    int_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+      attribute(:next) { |obj| obj + 1 }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :length, serializer: int_serializer, exposed: true
+    end
+
+    assert_equal(
+      {id: "S", length: {id: 6, next: 7}},
+      str_serializer.to_h("STRING")
+    )
+  end
+
+  it "returns empty array as empty has-many relationship" do
+    chr_serializer = Class.new(base_class)
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |_obj| "id" }
+      attribute :chars, serializer: chr_serializer, many: true, exposed: true
+    end
+
+    assert_equal({id: "id", chars: []}, str_serializer.to_h(""))
+  end
+
+  it "returns correct structure with has-many relationship" do
+    chr_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :chars, serializer: chr_serializer, many: true, exposed: true
+    end
+
+    assert_equal(
+      {id: "a", chars: [{id: "a"}, {id: "b"}]},
+      str_serializer.to_h("ab")
+    )
+  end
+
+  it "automatically checks if nested relationship is enumerable or single object" do
+    chr_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    int_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :chars, serializer: chr_serializer, exposed: true, many: true
+      attribute :length, serializer: int_serializer, exposed: true, many: false
+    end
+
+    assert_equal(
+      {id: "a", chars: [{id: "a"}, {id: "b"}], length: {id: 2}},
+      str_serializer.to_h("ab")
+    )
+  end
+
+  it "returns correct structure with has-many relationship with attributes" do
+    chr_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj }
+      attribute :next
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id) { |obj| obj[0] }
+      attribute :chars, serializer: chr_serializer, many: true, exposed: true
+    end
+
+    assert_equal(
+      {id: "a", chars: [{id: "a", next: "b"}, {id: "b", next: "c"}]},
+      str_serializer.to_h("ab")
+    )
+  end
+
+  it "accepts fields" do
+    # All fields are not exposed in this serializers,
+    # We will show only attributes provided in `fields` param
+    chr_serializer = Class.new(base_class) do
+      attribute(:id, exposed: false) { |obj| obj }
+      attribute :next, exposed: false
+    end
+
+    str_serializer = Class.new(base_class) do
+      attribute(:id, exposed: false) { |obj| obj }
+      attribute :chars, serializer: chr_serializer, many: true, exposed: false
+    end
+
+    assert_equal(
+      {chars: [{next: "b"}, {next: "c"}]},
+      str_serializer.to_h("ab", fields: "chars(next)")
+    )
+  end
+
+  describe "adding meta" do
+    it "returns correct structure with only 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 overwritten meta key" do
+      empty_serializer = Class.new(base_class)
+      empty_serializer.meta_key :metadata
+      empty_serializer.meta(:foo) { :bar }
+
+      assert_equal({metadata: {foo: :bar, any: :thing}}, empty_serializer.to_h(nil, meta: {any: :thing}))
+    end
+
+    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
+
+    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 "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
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApi" do
+  before { @plugin = Jat::Plugins.find_plugin(:simple_api) }
+
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.plugin(plugin)
+    new_class.root :data
+    new_class.attribute :id, key: :itself
+    new_class
+  end
+
+  let(:plugin) { @plugin }
+
+  describe ".after_load" 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.plugin(:simple_api)
+
+      assert_equal(:simple_api, jat_class.config[:response_plugin_loaded])
+    end
+  end
+
+  describe "InstanceMethods" do
+    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("JAT")
+      end
+    end
+
+    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
+
+    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 "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 "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.config[:meta_key]
+      end
+
+      it "changes meta key" do
+        jat_class.meta_key :metadata
+        assert_equal :metadata, jat_class.config[:meta_key]
+      end
+
+      it "symbolizes meta key" do
+        jat_class.meta_key "metadata"
+        assert_equal :metadata, jat_class.config[:meta_key]
+      end
+    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?(:_activerecord_preloads)
+  end
+end

data/test/lib/jat/plugins/simple_api_camel_lower/simple_api_camel_lower_test.rb

@@ -0,0 +1,48 @@
+# 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 "loads _lower_camel_case plugin" do
+    assert jat_class.plugin_used?(:_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

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