jat 0.0.7 → 0.0.8

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

@@ -52,137 +52,145 @@ describe "Jat::Plugins::JsonApi::Map" do
     ser
   end
 
-  describe "with default :exposed option" do
-    it "returns exposed by default attributes" do
-      result = described_class.call(exposed: :default)
-      expected_result = {
-        a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b]},
-        b: {serializer: b, attributes: %i[b1 b2], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
+  describe ".call" do
+    describe "with default :exposed option" do
+      it "returns exposed by default attributes" do
+        result = described_class.call(exposed: :default)
+        expected_result = {
+          a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b]},
+          b: {serializer: b, attributes: %i[b1 b2], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
+
+      it "returns exposed by default attributes when no :exposed param provided" do
+        result = described_class.call({})
+        expected_result = {
+          a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b]},
+          b: {serializer: b, attributes: %i[b1 b2], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
+
+      it "returns additionally included fields specified in :includes option" do
+        includes = "c,b.d"
+        result = described_class.call(include: includes)
+        expected_result = {
+          a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b c]},
+          b: {serializer: b, attributes: %i[b1 b2], relationships: %i[d]},
+          c: {serializer: c, attributes: %i[c1 c2], relationships: %i[]},
+          d: {serializer: d, attributes: %i[d1 d2], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
+
+      it "returns fields specified in :fields option (only specified fields for specified type)" do
+        fields = {b: "b1,d"}
+        result = described_class.call(fields: fields)
+        expected_result = {
+          a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b]},
+          b: {serializer: b, attributes: %i[b1], relationships: %i[d]},
+          d: {serializer: d, attributes: %i[d1 d2], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
+
+      it "returns fields specified in :includes and :fields options" do
+        includes = "c"
+        fields = {c: "c1"}
+        result = described_class.call(include: includes, fields: fields)
+        expected_result = {
+          a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b c]},
+          b: {serializer: b, attributes: %i[b1 b2], relationships: %i[]},
+          c: {serializer: c, attributes: %i[c1], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
     end
 
-    it "returns exposed by default attributes when no :exposed param provided" do
-      result = described_class.call({})
-      expected_result = {
-        a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b]},
-        b: {serializer: b, attributes: %i[b1 b2], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
-    end
-
-    it "returns additionally included fields specified in :includes option" do
-      includes = "c,b.d"
-      result = described_class.call(include: includes)
-      expected_result = {
-        a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b c]},
-        b: {serializer: b, attributes: %i[b1 b2], relationships: %i[d]},
-        c: {serializer: c, attributes: %i[c1 c2], relationships: %i[]},
-        d: {serializer: d, attributes: %i[d1 d2], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
-    end
-
-    it "returns fields specified in :fields option (only specified fields for specified type)" do
-      fields = {b: "b1,d"}
-      result = described_class.call(fields: fields)
-      expected_result = {
-        a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b]},
-        b: {serializer: b, attributes: %i[b1], relationships: %i[d]},
-        d: {serializer: d, attributes: %i[d1 d2], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
+    describe "with exposed: :none option" do
+      it "returns no attributes" do
+        result = described_class.call(exposed: :none)
+        expected_result = {
+          a: {serializer: a, attributes: %i[], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
+
+      it "returns additionally included fields specified in :includes option" do
+        includes = "b.c"
+        result = described_class.call(exposed: :none, include: includes)
+        expected_result = {
+          a: {serializer: a, attributes: %i[], relationships: %i[b]},
+          b: {serializer: b, attributes: %i[], relationships: %i[c]},
+          c: {serializer: c, attributes: %i[], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
+
+      it "returns fields specified in :fields option (only specified fields for specified type)" do
+        fields = {a: "a1,b", b: "b1,d"}
+        result = described_class.call(exposed: :none, fields: fields)
+        expected_result = {
+          a: {serializer: a, attributes: %i[a1], relationships: %i[b]},
+          b: {serializer: b, attributes: %i[b1], relationships: %i[d]},
+          d: {serializer: d, attributes: %i[], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
+
+      it "returns fields specified in :includes and :fields options" do
+        includes = "c"
+        fields = {c: "c1"}
+        result = described_class.call(exposed: :none, include: includes, fields: fields)
+        expected_result = {
+          a: {serializer: a, attributes: %i[], relationships: %i[c]},
+          c: {serializer: c, attributes: %i[c1], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
     end
 
-    it "returns fields specified in :includes and :fields options" do
-      includes = "c"
-      fields = {c: "c1"}
-      result = described_class.call(include: includes, fields: fields)
-      expected_result = {
-        a: {serializer: a, attributes: %i[a1 a2], relationships: %i[b c]},
-        b: {serializer: b, attributes: %i[b1 b2], relationships: %i[]},
-        c: {serializer: c, attributes: %i[c1], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
+    describe "with exposed: :all option" do
+      it "returns all attributes" do
+        result = described_class.call(exposed: :all)
+        expected_result = {
+          a: {serializer: a, attributes: %i[a1 a2 a3], relationships: %i[b c d]},
+          b: {serializer: b, attributes: %i[b1 b2 b3], relationships: %i[c d]},
+          c: {serializer: c, attributes: %i[c1 c2 c3], relationships: %i[]},
+          d: {serializer: d, attributes: %i[d1 d2 d3], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
+
+      it "returns only specified fields for specified fields types" do
+        fields = {b: "b1", c: "c2"}
+        result = described_class.call(exposed: :all, fields: fields)
+        expected_result = {
+          a: {serializer: a, attributes: %i[a1 a2 a3], relationships: %i[b c d]},
+          b: {serializer: b, attributes: %i[b1], relationships: %i[]},
+          c: {serializer: c, attributes: %i[c2], relationships: %i[]},
+          d: {serializer: d, attributes: %i[d1 d2 d3], relationships: %i[]}
+        }
+
+        assert_equal expected_result, result
+      end
     end
   end
 
-  describe "with exposed: :none option" do
-    it "returns no attributes" do
-      result = described_class.call(exposed: :none)
-      expected_result = {
-        a: {serializer: a, attributes: %i[], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
-    end
-
-    it "returns additionally included fields specified in :includes option" do
-      includes = "b.c"
-      result = described_class.call(exposed: :none, include: includes)
-      expected_result = {
-        a: {serializer: a, attributes: %i[], relationships: %i[b]},
-        b: {serializer: b, attributes: %i[], relationships: %i[c]},
-        c: {serializer: c, attributes: %i[], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
-    end
-
-    it "returns fields specified in :fields option (only specified fields for specified type)" do
-      fields = {a: "a1,b", b: "b1,d"}
-      result = described_class.call(exposed: :none, fields: fields)
-      expected_result = {
-        a: {serializer: a, attributes: %i[a1], relationships: %i[b]},
-        b: {serializer: b, attributes: %i[b1], relationships: %i[d]},
-        d: {serializer: d, attributes: %i[], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
-    end
-
-    it "returns fields specified in :includes and :fields options" do
-      includes = "c"
-      fields = {c: "c1"}
-      result = described_class.call(exposed: :none, include: includes, fields: fields)
-      expected_result = {
-        a: {serializer: a, attributes: %i[], relationships: %i[c]},
-        c: {serializer: c, attributes: %i[c1], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
-    end
-  end
-
-  describe "with exposed: :all option" do
-    it "returns all attributes" do
-      result = described_class.call(exposed: :all)
-      expected_result = {
-        a: {serializer: a, attributes: %i[a1 a2 a3], relationships: %i[b c d]},
-        b: {serializer: b, attributes: %i[b1 b2 b3], relationships: %i[c d]},
-        c: {serializer: c, attributes: %i[c1 c2 c3], relationships: %i[]},
-        d: {serializer: d, attributes: %i[d1 d2 d3], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
-    end
-
-    it "returns only specified fields for specified fields types" do
-      fields = {b: "b1", c: "c2"}
-      result = described_class.call(exposed: :all, fields: fields)
-      expected_result = {
-        a: {serializer: a, attributes: %i[a1 a2 a3], relationships: %i[b c d]},
-        b: {serializer: b, attributes: %i[b1], relationships: %i[]},
-        c: {serializer: c, attributes: %i[c2], relationships: %i[]},
-        d: {serializer: d, attributes: %i[d1 d2 d3], relationships: %i[]}
-      }
-
-      assert_equal expected_result, result
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{a}::Map", described_class.inspect
     end
   end
 end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApi::ResponsePiece" do
+  let(:jat_class) { Class.new(Jat) { plugin :json_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/json_api/lib/response_test.rb

@@ -486,4 +486,10 @@ describe "Jat::Plugins::JsonApi::Response" do
       assert_equal({self: "/self", related: "/foo/self"}, links)
     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/json_api_activerecord/json_api_activerecord_test.rb

@@ -19,6 +19,6 @@ describe "Jat::Plugins::JsonApiActiverecord" do
     jat_class.plugin :json_api_activerecord
 
     assert jat_class.plugin_used?(:json_api_preloads)
-    assert jat_class.plugin_used?(:_activerecord_preloads)
+    assert jat_class.plugin_used?(:base_activerecord_preloads)
   end
 end

data/test/lib/jat/plugins/{json_api_camel_lower/json_api_camel_lower_test.rb → json_api_lower_camel_case/json_api_lower_camel_case_test.rb}

@@ -15,6 +15,12 @@ describe "Jat::Plugins::JsonApiLowerCamelCase" do
     jat_class.id { |object| object }
   end
 
+  it "checks json_api plugin loaded before" do
+    jat_class = Class.new(Jat)
+    error = assert_raises(Jat::Error) { jat_class.plugin :json_api_lower_camel_case }
+    assert_match(/json_api/, error.message)
+  end
+
   it "returns attributes in lowerCamelCase case" do
     jat_class.attribute(:foo_bar) { 1 }
 

data/test/lib/jat/plugins/json_api_preloads/json_api_preloads_test.rb

@@ -17,13 +17,13 @@ describe "Jat::Plugins::JsonApiPreloads" do
     jat_class = Class.new(Jat)
     jat_class.plugin :json_api
 
-    jat_class.expects(:plugin).with(:_preloads, foo: :bar)
+    jat_class.expects(:plugin).with(:base_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
+    it "adds #preloads method as a delegator to #{@plugin}::Preloads" do
       jat_class = Class.new(Jat)
       jat_class.plugin :json_api
       jat_class.plugin @plugin
@@ -34,4 +34,18 @@ describe "Jat::Plugins::JsonApiPreloads" do
       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 :json_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/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,75 @@ 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 single resource with multiple fields" do
+      assert_equal({users: {id: {}, name: {}}}, parse("users(id,name)"))
+    end
 
-    assert_equal(resp, parse(fields))
-  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