jat 0.0.5 → 0.0.9

data/test/lib/jat/plugins/json_api_validate_params/json_api_validate_params_test.rb

@@ -13,34 +13,50 @@ describe "Jat::Plugins::JsonApiValidateParams" do
     assert_match(/json_api/, error.message)
   end
 
-  let(:serializer) do
+  let(:base) do
     jat_class = Class.new(Jat)
     jat_class.plugin :json_api
+    jat_class
+  end
+
+  let(:serializer) do
+    jat_class = Class.new(base)
     jat_class.plugin @plugin
 
     jat_class.type "foo"
     jat_class.attribute :foo_bar
-    jat_class.relationship :foo_bazz, serializer: jat_class
+    jat_class.relationship :foo_bazz, serializer: foo_bazz_serializer
+    jat_class
+  end
+
+  let(:foo_bazz_serializer) do
+    jat_class = Class.new(base)
+    jat_class.type "foo_bazz"
+    jat_class.attribute :bazz
     jat_class
   end
 
   let(:serializer_lower_camel_case) do
-    jat_class = Class.new(Jat)
-    jat_class.plugin :json_api
+    jat_class = Class.new(base)
     jat_class.plugin :json_api_lower_camel_case
     jat_class.plugin @plugin
 
     jat_class.type "foo"
     jat_class.attribute :foo_bar
-    jat_class.relationship :foo_bazz, serializer: jat_class
+    jat_class.relationship :foo_bazz, serializer: foo_bazz_serializer
     jat_class
   end
 
+  it "returns true when provided fields present" do
+    jat = serializer.new(fields: {foo: "foo_bar,foo_bazz", foo_bazz: "bazz"})
+    assert jat.validate
+  end
+
   it "validates fields types" do
     jat = serializer.new(fields: {bar: "any"})
     error = assert_raises(Jat::JsonApiParamsError) { jat.validate }
 
-    expected_message = "Response does not have resources with type 'bar'. Existing types are: 'foo'"
+    expected_message = "Response does not have resources with type 'bar'. Existing types are: 'foo', 'foo_bazz'"
     assert_equal(expected_message, error.message)
   end
 
@@ -81,4 +97,12 @@ describe "Jat::Plugins::JsonApiValidateParams" do
     expected_message = "Type 'foo' has no included 'extra' relationship. Existing relationships are: 'fooBazz'"
     assert_equal(expected_message, error.message)
   end
+
+  it "validates nested includes" do
+    jat = serializer.new(include: "foo_bazz.extra")
+    error = assert_raises(Jat::JsonApiParamsError) { jat.validate }
+
+    expected_message = "Type 'foo_bazz' has no included 'extra' relationship. Existing relationships are: ''"
+    assert_equal(expected_message, error.message)
+  end
 end

data/test/lib/jat/plugins/lower_camel_case/lower_camel_case_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::LowerCamelCase" do
+  it "raises error if no response plugin is loaded" do
+    new_class = Class.new(Jat)
+    err = assert_raises(Jat::Error) { new_class.plugin :lower_camel_case }
+    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 :lower_camel_case
+
+    assert new_class.plugin_used?(:simple_api_lower_camel_case)
+  end
+
+  it "loads json_api compatible plugin" do
+    new_class = Class.new(Jat)
+    new_class.plugin :json_api
+    new_class.plugin :lower_camel_case
+
+    assert new_class.plugin_used?(:json_api_lower_camel_case)
+  end
+end

data/test/lib/jat/plugins/maps_cache/maps_cache_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::MapsCache" do
+  it "raises error if no response plugin is loaded" do
+    new_class = Class.new(Jat)
+    err = assert_raises(Jat::Error) { new_class.plugin :maps_cache }
+    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 :maps_cache
+
+    assert new_class.plugin_used?(:simple_api_maps_cache)
+  end
+
+  it "loads json_api compatible plugin" do
+    new_class = Class.new(Jat)
+    new_class.plugin :json_api
+    new_class.plugin :maps_cache
+
+    assert new_class.plugin_used?(:json_api_maps_cache)
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::Preloads" do
+  it "raises error if no response plugin is loaded" do
+    new_class = Class.new(Jat)
+    err = assert_raises(Jat::Error) { new_class.plugin :preloads }
+    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 :preloads
+
+    assert new_class.plugin_used?(:simple_api_preloads)
+  end
+
+  it "loads json_api compatible plugin" do
+    new_class = Class.new(Jat)
+    new_class.plugin :json_api
+    new_class.plugin :preloads
+
+    assert new_class.plugin_used?(:json_api_preloads)
+  end
+end

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

@@ -13,65 +13,79 @@ describe "Jat::Plugins::SimpleApi::FieldsParamParser" do
     ser
   end
 
+  let(:described_class) { jat_class::FieldsParamParser }
+
   def parse(str)
     jat_class::FieldsParamParser.parse(str)
   end
 
-  it "returns empty hash when nil provided" do
-    assert_equal({}, parse(nil))
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{jat_class}::FieldsParamParser", described_class.inspect
+    end
   end
 
-  it "returns empty hash when empty string provided" do
-    assert_equal({}, parse(""))
-  end
+  describe ".parse" do
+    it "returns empty hash when nil provided" do
+      assert_equal({}, parse(nil))
+    end
 
-  it "parses single field" do
-    assert_equal({id: {}}, parse("id"))
-  end
+    it "returns empty hash when empty string provided" do
+      assert_equal({}, parse(""))
+    end
 
-  it "parses multiple fields" do
-    assert_equal({id: {}, name: {}}, parse("id, name"))
-  end
+    it "parses single field" do
+      assert_equal({id: {}}, parse("id"))
+    end
 
-  it "parses single resource with single field" do
-    assert_equal({users: {id: {}}}, parse("users(id)"))
-  end
+    it "parses multiple fields" do
+      assert_equal({id: {}, name: {}}, parse("id, name"))
+    end
 
-  it "parses fields started with open PAREN" do
-    assert_equal({users: {id: {}}}, parse("(users(id))"))
-  end
+    it "parses single resource with single field" do
+      assert_equal({users: {id: {}}}, parse("users(id)"))
+    end
 
-  it "parses single resource with multiple fields" do
-    assert_equal({users: {id: {}, name: {}}}, parse("users(id,name)"))
-  end
+    it "parses fields started with open PAREN" do
+      assert_equal({users: {id: {}}}, parse("(users(id))"))
+    end
 
-  it "parses multiple resources with fields" do
-    fields = "id,posts(title,text),news(title,text)"
-    resp = {
-      id: {},
-      posts: {title: {}, text: {}},
-      news: {title: {}, text: {}}
-    }
+    it "parses fields started with extra close PAREN" do
+      assert_equal({users: {}}, parse(")users)"))
+    end
 
-    assert_equal(resp, parse(fields))
-  end
+    it "parses single resource with multiple fields" do
+      assert_equal({users: {id: {}, name: {}}}, parse("users(id,name)"))
+    end
+
+    it "parses multiple resources with fields" do
+      fields = "id,posts(title,text),news(title,text)"
+      resp = {
+        id: {},
+        posts: {title: {}, text: {}},
+        news: {title: {}, text: {}}
+      }
+
+      assert_equal(resp, parse(fields))
+    end
 
-  it "parses included resources" do
-    fields = "id,posts(title,text,comments(author(name),comment))"
-    resp = {
-      id: {},
-      posts: {
-        title: {},
-        text: {},
-        comments: {
-          author: {
-            name: {}
-          },
-          comment: {}
+    it "parses included resources" do
+      fields = "id,posts(title,text,comments(author(name),comment))"
+      resp = {
+        id: {},
+        posts: {
+          title: {},
+          text: {},
+          comments: {
+            author: {
+              name: {}
+            },
+            comment: {}
+          }
         }
       }
-    }
 
-    assert_equal(resp, parse(fields))
+      assert_equal(resp, parse(fields))
+    end
   end
 end

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

@@ -45,89 +45,97 @@ describe "Jat::Plugins::SimpleApi::Map" do
     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
+  describe ".call" do
+    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
+
+    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: {}}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    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: {}}
+      }
+
+      assert_equal expected_result, result
+    end
+
+    it "raises error with informative message about recursive serialization" do
+      a.relationship :b, serializer: -> { b }, exposed: true
+      b.relationship :a, serializer: -> { a }, exposed: true
+
+      error = assert_raises(Jat::Error) { described_class.call({}) }
+      assert_includes "Recursive serialization: b -> a -> b", error.message
+    end
+
+    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
+
+      error = assert_raises(Jat::Error) { described_class.call({}) }
+      assert_equal "Recursive serialization: b -> c -> a -> b", error.message
+    end
   end
 
-  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: {}}
-    }
-
-    assert_equal expected_result, result
-  end
-
-  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: {}}
-    }
-
-    assert_equal expected_result, result
-  end
-
-  it "raises error with informative message about recursive serialization" do
-    a.relationship :b, serializer: -> { b }, exposed: true
-    b.relationship :a, serializer: -> { a }, exposed: true
-
-    error = assert_raises(Jat::Error) { described_class.call({}) }
-    assert_includes "Recursive serialization: b -> a -> b", error.message
-  end
-
-  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
-
-    error = assert_raises(Jat::Error) { described_class.call({}) }
-    assert_equal "Recursive serialization: b -> c -> a -> b", error.message
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{a}::Map", described_class.inspect
+    end
   end
 end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::SimpleApi::ResponsePiece" do
+  let(:jat_class) { Class.new(Jat) { plugin :simple_api } }
+
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{jat_class}::ResponsePiece", jat_class::ResponsePiece.inspect
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ describe "Jat::Plugins::SimpleApi::Response" do
 
   it "returns correct structure with data" do
     str_serializer = Class.new(base_class) do
-      attribute(:id) { |_| "STRING" }
+      attribute(:id) { |obj| obj }
     end
 
     assert_equal({id: "STRING"}, str_serializer.to_h("STRING"))
@@ -92,7 +92,8 @@ describe "Jat::Plugins::SimpleApi::Response" do
     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))
+    assert_equal({foo: {id: "1"}}, str_serializer.to_h("1", root: "foo"))
+    assert_equal({id: "1"}, str_serializer.to_h("1", root: nil))
   end
 
   it "returns correct structure with data multiple attributes" do
@@ -131,13 +132,11 @@ describe "Jat::Plugins::SimpleApi::Response" do
   end
 
   it "does not return has-one relationship when not exposed" do
-    int_serializer = Class.new(base_class) do
-      attribute(:id) { |obj| obj }
-    end
+    nested_serializer = Class.new(base_class)
 
     str_serializer = Class.new(base_class) do
       attribute(:id) { |obj| obj[0] }
-      attribute :length, serializer: int_serializer, exposed: false
+      attribute :length, serializer: nested_serializer, exposed: false
     end
 
     assert_equal({id: "S"}, str_serializer.to_h("STRING"))
@@ -242,12 +241,12 @@ describe "Jat::Plugins::SimpleApi::Response" 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(:id, exposed: false)
       attribute :next, exposed: false
     end
 
     str_serializer = Class.new(base_class) do
-      attribute(:id, exposed: false) { |obj| obj }
+      attribute(:id, exposed: false)
       attribute :chars, serializer: chr_serializer, many: true, exposed: false
     end
 
@@ -269,7 +268,8 @@ describe "Jat::Plugins::SimpleApi::Response" do
       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}))
+      assert_equal({metadata: {foo: :bar}}, empty_serializer.to_h(nil))
+      assert_equal({new_meta: {foo: :bar}}, empty_serializer.to_h(nil, meta_key: "new_meta"))
     end
 
     it "returns correct structure with data and meta" do
@@ -306,14 +306,14 @@ describe "Jat::Plugins::SimpleApi::Response" do
     it "does not overwrite manually added meta" do
       str_serializer = Class.new(base_class) do
         root(:root)
-        meta(:version) { "1.2.3" }
+        meta(:length)
 
         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"})
+        {root: {id: "1"}, meta: {length: "33"}},
+        str_serializer.to_h("1", meta: {length: "33"})
       )
     end
 
@@ -345,4 +345,10 @@ describe "Jat::Plugins::SimpleApi::Response" do
       assert_equal({root: {id: "1"}}, str_serializer.to_h("1", bazz: nil))
     end
   end
+
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{base_class}::Response", base_class::Response.inspect
+    end
+  end
 end

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

@@ -15,15 +15,17 @@ describe "Jat::Plugins::SimpleApi" do
 
   let(:plugin) { @plugin }
 
-  describe ".after_load" do
-    it "loads simple_api_activerecord plugin if activerecord option provided" do
+  describe ".before_load" do
+    it "raises error if response plugin was already loaded" do
       jat_class = Class.new(Jat)
-      jat_class.expects(:plugin).with(:simple_api_activerecord, activerecord: true)
+      jat_class.config[:response_plugin_loaded] = :foobar
 
-      plugin.load(jat_class)
-      plugin.after_load(jat_class, activerecord: true)
+      err = assert_raises(Jat::Error) { jat_class.plugin(:simple_api) }
+      assert_equal("Response plugin `foobar` was already loaded before", err.message)
     end
+  end
 
+  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]
@@ -54,7 +56,7 @@ describe "Jat::Plugins::SimpleApi" do
     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")
+        assert_equal "MAP", jat_class.new("CONTEXT").map
       end
     end
 
@@ -143,5 +145,30 @@ describe "Jat::Plugins::SimpleApi" do
         assert_equal :metadata, jat_class.config[:meta_key]
       end
     end
+
+    describe ".inherited" do
+      it "inherits root" do
+        jat_class.root(:foo)
+        child = Class.new(jat_class)
+        assert_equal :foo, child.config[:root_one]
+        assert_equal :foo, child.config[:root_many]
+      end
+
+      it "inherits meta" do
+        jat_class.meta(:foo) { "bar" }
+        child = Class.new(jat_class)
+
+        assert_equal "bar", child.added_meta[:foo].value(nil, nil)
+      end
+
+      it "does not change parents meta when children meta changed" do
+        jat_class.meta(:foo) { "foo" }
+        child = Class.new(jat_class)
+        child.meta(:foo) { "bazz" }
+
+        assert_equal("foo", jat_class.added_meta[:foo].value(nil, nil))
+        assert_equal("bazz", child.added_meta[:foo].value(nil, nil))
+      end
+    end
   end
 end

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

@@ -13,26 +13,12 @@ describe "Jat::Plugins::SimpleApiActiverecord" do
     assert_match(/simple_api/, error.message)
   end
 
-  it "loads other plugins in after_load" do
+  it "loads other plugins" do
     jat_class = Class.new(Jat)
     jat_class.plugin :simple_api
+    jat_class.plugin :simple_api_activerecord
 
-    jat_class.expects(:plugin).with(:_preloads, foo: :bar)
-    jat_class.expects(:plugin).with(:_activerecord_preloads, foo: :bar)
-
-    @plugin.after_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
+    assert jat_class.plugin_used?(:simple_api_preloads)
+    assert jat_class.plugin_used?(:base_activerecord_preloads)
   end
 end

data/test/lib/jat/plugins/{simple_api_camel_lower/simple_api_camel_lower_test.rb → simple_api_lower_camel_case/simple_api_lower_camel_case_test.rb}

@@ -10,8 +10,14 @@ describe "Jat::Plugins::SimpleApiLowerCamelCase" do
     new_class
   end
 
+  it "checks simple_api plugin loaded before" do
+    jat_class = Class.new(Jat)
+    error = assert_raises(Jat::Error) { jat_class.plugin :simple_api_lower_camel_case }
+    assert_match(/simple_api/, error.message)
+  end
+
   it "loads _lower_camel_case plugin" do
-    assert jat_class.plugin_used?(:_lower_camel_case)
+    assert jat_class.plugin_used?(:base_lower_camel_case)
   end
 
   it "returns attributes in lowerCamelCase case" do