jat 0.0.5 → 0.0.9

data/test/lib/jat/plugins/{_camel_lower/_camel_lower_test.rb → base_lower_camel_case/base_lower_camel_case_test.rb}

@@ -2,10 +2,10 @@
 
 require "test_helper"
 
-describe "Jat::Plugins::LowerCamelCase" do
+describe "Jat::Plugins::BaseLowerCamelCase" do
   let(:jat_class) do
     new_class = Class.new(Jat)
-    new_class.plugin(:_lower_camel_case)
+    new_class.plugin(:base_lower_camel_case)
     new_class
   end
 

data/test/lib/jat/plugins/{_preloads/_preloads_test.rb → base_preloads/base_preloads_test.rb}

@@ -2,9 +2,9 @@
 
 require "test_helper"
 
-describe "Jat::Plugins::Preloads" do
+describe "Jat::Plugins::BasePreloads" do
   let(:jat_class) do
-    Class.new(Jat) { plugin(:_preloads) }
+    Class.new(Jat) { plugin(:base_preloads) }
   end
 
   def attribute(name, opts)

data/test/lib/jat/plugins/{_preloads → base_preloads}/lib/format_user_preloads_test.rb

@@ -2,10 +2,10 @@
 
 require "test_helper"
 
-describe "Jat::Plugins::Preloads::FormatUserPreloads" do
-  before { Jat::Plugins.find_plugin(:_preloads) }
+describe "Jat::Plugins::BasePreloads::FormatUserPreloads" do
+  before { Jat::Plugins.find_plugin(:base_preloads) }
 
-  let(:format) { Jat::Plugins::Preloads::FormatUserPreloads }
+  let(:format) { Jat::Plugins::BasePreloads::FormatUserPreloads }
 
   it "transforms nil to empty hash" do
     preloads = nil

data/test/lib/jat/plugins/{_preloads → base_preloads}/lib/preloads_with_path_test.rb

@@ -3,9 +3,9 @@
 require "test_helper"
 
 describe "Jat::Plugins::Preloads::PreloadsWithPath" do
-  before { Jat::Plugins.find_plugin(:_preloads) }
+  before { Jat::Plugins.find_plugin(:base_preloads) }
 
-  let(:described_class) { Jat::Plugins::Preloads::PreloadsWithPath }
+  let(:described_class) { Jat::Plugins::BasePreloads::PreloadsWithPath }
 
   it "returns provided preloads and path to last value" do
     preloads = {a: {b: {c: {}}, d: {}}, e: {}}

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

@@ -23,14 +23,6 @@ describe "Jat::Plugins::JsonApi" do
   end
 
   describe ".after_load" do
-    it "loads json_api_activerecord plugin if activerecord option provided" do
-      jat_class = Class.new(Jat)
-      jat_class.expects(:plugin).with(:json_api_activerecord, activerecord: true)
-
-      plugin.load(jat_class)
-      plugin.after_load(jat_class, activerecord: true)
-    end
-
     it "adds config variable with name of response plugin that was loaded" do
       jat_class = Class.new(Jat)
       jat_class.plugin(:json_api)
@@ -54,7 +46,7 @@ describe "Jat::Plugins::JsonApi" 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
 

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

@@ -18,21 +18,29 @@ describe "Jat::Plugins::JsonApi::FieldsParamParser" do
 
   let(:described_class) { jat_class::FieldsParamParser }
 
-  it "returns empty hash when parameters not provided" do
-    result = described_class.parse(nil)
-
-    assert_equal({}, result)
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{jat_class}::FieldsParamParser", described_class.inspect
+    end
   end
 
-  it "returns parsed attributes" do
-    result = described_class.parse(a: "a1,a2")
+  describe ".parse" do
+    it "returns empty hash when parameters not provided" do
+      result = described_class.parse(nil)
 
-    assert_equal({a: %i[a1 a2]}, result)
-  end
+      assert_equal({}, result)
+    end
 
-  it "validates provided attributes" do
-    jat_class.plugin :json_api_validate_params
-    error = assert_raises(Jat::Error) { described_class.parse(a: "a1,a2,a3,a4") }
-    assert_match(/a4/, error.message)
+    it "returns parsed attributes" do
+      result = described_class.parse(a: "a1,a2")
+
+      assert_equal({a: %i[a1 a2]}, result)
+    end
+
+    it "validates provided attributes" do
+      jat_class.plugin :json_api_validate_params
+      error = assert_raises(Jat::Error) { described_class.parse(a: "a1,a2,a3,a4") }
+      assert_match(/a4/, error.message)
+    end
   end
 end

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

@@ -3,11 +3,10 @@
 require "test_helper"
 
 describe "Jat::Plugins::JsonApi::Params::Include" do
-  before { Jat::Plugins.find_plugin(:json_api) }
-
   let(:base_class) { Class.new(Jat) { plugin :json_api } }
   let(:a_serializer) { Class.new(base_class) }
   let(:b_serializer) { Class.new(base_class) }
+  let(:c_serializer) { Class.new(base_class) }
 
   before do
     ser = a_serializer
@@ -22,20 +21,35 @@ describe "Jat::Plugins::JsonApi::Params::Include" do
     ser = b_serializer
     ser.type :b
     ser.attribute :b1
-    ser.relationship :b2, serializer: a_serializer
-    ser.relationship :b3, serializer: a_serializer
-    ser.relationship :b4, serializer: a_serializer
+    ser.relationship :b2, serializer: c_serializer
+    ser.relationship :b3, serializer: c_serializer
+    ser.relationship :b4, serializer: c_serializer
+
+    ser = c_serializer
+    ser.type :c
+    ser.attribute :c1
+    ser.relationship :c2, serializer: a_serializer
+    ser.relationship :c3, serializer: a_serializer
+    ser.relationship :c4, serializer: a_serializer
   end
 
   let(:described_class) { a_serializer::IncludeParamParser }
 
-  it "returns empty hash when param not provided" do
-    result = described_class.parse(nil)
-    assert_equal({}, result)
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{a_serializer}::IncludeParamParser", described_class.inspect
+    end
   end
 
-  it "returns typed keys" do
-    result = described_class.parse("a2.b2,a2.b3,a3.b2.a5,a4")
-    assert_equal({a: %i[a2 a3 a5 a4], b: %i[b2 b3]}, result)
+  describe ".parse" do
+    it "returns empty hash when param not provided" do
+      result = described_class.parse(nil)
+      assert_equal({}, result)
+    end
+
+    it "returns typed keys" do
+      result = described_class.parse("a2.b2.c2,a2.b2.c3,a3.b2.c4.a5,a4")
+      assert_equal({a: %i[a2 a3 a5 a4], b: %i[b2], c: %i[c2 c3 c4]}, result)
+    end
   end
 end

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

@@ -76,7 +76,6 @@ describe "Jat::Plugins::JsonApi::Response" do
   it "does not return has-one relationship when not exposed" do
     int_serializer = Class.new(base_class) do
       type "int"
-      id { |obj| obj }
     end
 
     str_serializer = Class.new(base_class) do
@@ -486,4 +485,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

@@ -13,26 +13,12 @@ describe "Jat::Plugins::JsonApiActiverecord" do
     assert_match(/json_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 :json_api
+    jat_class.plugin :json_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 :json_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?(:json_api_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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::JsonApiPreloads" do
+  before do
+    @plugin = Jat::Plugins.find_plugin(:json_api_preloads)
+  end
+
+  it "checks json_api plugin loaded before" do
+    jat_class = Class.new(Jat)
+    error = assert_raises(Jat::Error) { jat_class.plugin @plugin }
+    assert_match(/json_api/, error.message)
+  end
+
+  it "loads other plugins" do
+    jat_class = Class.new(Jat)
+    jat_class.plugin :json_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 :json_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 :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_activerecord → json_api_preloads}/lib/preloads_test.rb

@@ -2,18 +2,20 @@
 
 require "test_helper"
 
-describe "Jat::Plugins::JsonApiActiverecord::Preloads" do
-  let(:base) { Class.new(Jat) { plugin :json_api, activerecord: true } }
+describe "Jat::Plugins::JsonApiPreloads::Preloads" do
+  let(:base) do
+    Class.new(Jat) do
+      plugin :json_api
+      plugin :json_api_preloads
+    end
+  end
 
   let(:user_serializer) { Class.new(base) { type(:user) } }
   let(:profile_serializer) { Class.new(base) { type(:profile) } }
   let(:email_serializer) { Class.new(base) { type(:email) } }
 
   let(:jat_user) { user_serializer.allocate }
-  let(:jat_profile) { profile_serializer.allocate }
-  let(:jat_email) { email_serializer.allocate }
-
-  let(:described_class) { Jat::Plugins::JsonApiActiverecord::Preloads }
+  let(:described_class) { Jat::Plugins::JsonApiPreloads::Preloads }
 
   def define_map(map)
     jat_user.expects(:map).returns(map)