jat 0.0.3 → 0.0.5

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

@@ -7,77 +7,93 @@ describe "Jat::Plugins::JsonApi" do
     new_class = Class.new(Jat)
     new_class.plugin(plugin)
     new_class.type :jat
-    new_class.attribute :id, key: :itself
+    new_class.id key: :itself
     new_class
   end
 
-  let(:plugin) { Jat::Plugins.load_plugin(:json_api) }
+  let(:plugin) { Jat::Plugins.find_plugin(:json_api) }
+
+  describe ".before_load" do
+    it "checks some response plugin was already loaded" do
+      jat_class = Class.new(Jat)
+      jat_class.config[:response_plugin_loaded] = :simple_api
+      error = assert_raises(Jat::Error) { jat_class.plugin(:json_api) }
+      assert_equal "Response plugin `simple_api` was already loaded before", error.message
+    end
+  end
 
   describe ".after_load" do
-    it "loads _json_api_activerecord plugin if activerecord option provided" 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)
+      jat_class.expects(:plugin).with(:json_api_activerecord, activerecord: true)
 
-      Jat::Plugins.after_load(plugin, jat_class, activerecord: true)
+      plugin.load(jat_class)
+      plugin.after_load(jat_class, activerecord: true)
     end
 
-    it "registers Presenters constants" do
+    it "adds config variable with name of response plugin that was loaded" do
       jat_class = Class.new(Jat)
-      Jat::Plugins.after_load(plugin, jat_class, activerecord: true)
-
-      assert_equal jat_class::JsonapiPresenter.jat_class, jat_class
-      assert_equal jat_class::LinksPresenter.jat_class, jat_class
-      assert_equal jat_class::DocumentLinksPresenter.jat_class, jat_class
-      assert_equal jat_class::RelationshipLinksPresenter.jat_class, jat_class
-      assert_equal jat_class::MetaPresenter.jat_class, jat_class
-      assert_equal jat_class::DocumentMetaPresenter.jat_class, jat_class
-      assert_equal jat_class::RelationshipMetaPresenter.jat_class, jat_class
+      jat_class.plugin(:json_api)
+
+      assert_equal(:json_api, jat_class.config[:response_plugin_loaded])
     end
   end
 
   describe "InstanceMethods" do
     let(:jat) do
-      jat_class.new("JAT", {})
+      jat_class.new
     end
 
     describe "#to_h" do
       it "returns response in json-api format" do
         expected_result = {data: {type: :jat, id: "JAT"}}
-        assert_equal expected_result, jat.to_h
+        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 "#traversal_map" do
-      it "returns memorized traversal_map object" do
-        assert_equal jat.traversal_map.class, Jat::Plugins::JsonApi::TraversalMap
-        assert_same jat.traversal_map, jat.traversal_map
+    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 ".relationship" do
-      it "adds new attribute with required serializer" do
-        jat_class.relationship(:foo, serializer: jat_class, exposed: true) { "block" }
-
-        atribute = jat_class.attributes[:foo]
-        assert_equal jat_class, atribute.serializer
-        assert_equal true, atribute.exposed?
-        assert_equal "block", jat_class::Presenter.new(nil, nil).foo
+    describe ".id" do
+      it "adds new `:id`" do
+        jat_class.id(key: :uuid)
+        assert_equal jat_class.get_id.params, {name: :id, opts: {key: :uuid}, block: nil}
       end
     end
 
     describe ".inherited" do
       it "inherits type" do
         child = Class.new(jat_class)
-        assert_equal :jat, child.type
+        assert_equal :jat, child.get_type
       end
 
       it "inherits `jsonapi` data" do
         jat_class.jsonapi(:version) { "1.0" }
 
         child = Class.new(jat_class)
-        assert_equal("1.0", child.jsonapi_data[:version].call)
+        assert_equal("1.0", child.jsonapi_data[:version].value(nil, nil))
       end
 
       it "inherits `object_links`, `relationship_links`, `document_links`" do
@@ -86,9 +102,9 @@ describe "Jat::Plugins::JsonApi" do
         jat_class.document_link(:last) { "/articles/3" }
         child = Class.new(jat_class)
 
-        assert_equal("/articles/1", child.object_links[:self].call)
-        assert_equal("/articles/2", child.relationship_links[:related].call)
-        assert_equal("/articles/3", child.document_links[:last].call)
+        assert_equal("/articles/1", child.object_links[:self].value(nil, nil))
+        assert_equal("/articles/2", child.relationship_links[:related].value(nil, nil))
+        assert_equal("/articles/3", child.document_links[:last].value(nil, nil))
       end
 
       it "does not change parents links when children links are changed" do
@@ -101,9 +117,9 @@ describe "Jat::Plugins::JsonApi" do
         child.relationship_links.delete(:related)
         child.document_links.delete(:last)
 
-        assert_equal("/articles/1", jat_class.object_links[:self].call)
-        assert_equal("/articles/2", jat_class.relationship_links[:related].call)
-        assert_equal("/articles/3", jat_class.document_links[:last].call)
+        assert_equal("/articles/1", jat_class.object_links[:self].value(nil, nil))
+        assert_equal("/articles/2", jat_class.relationship_links[:related].value(nil, nil))
+        assert_equal("/articles/3", jat_class.document_links[:last].value(nil, nil))
       end
 
       it "inherits `object_meta`, `relationship_meta`, `document_meta`" do
@@ -112,9 +128,9 @@ describe "Jat::Plugins::JsonApi" do
         jat_class.document_meta(:last) { "foo/3" }
         child = Class.new(jat_class)
 
-        assert_equal("foo/1", child.added_object_meta[:self].call)
-        assert_equal("foo/2", child.added_relationship_meta[:related].call)
-        assert_equal("foo/3", child.added_document_meta[:last].call)
+        assert_equal("foo/1", child.added_object_meta[:self].value(nil, nil))
+        assert_equal("foo/2", child.added_relationship_meta[:related].value(nil, nil))
+        assert_equal("foo/3", child.added_document_meta[:last].value(nil, nil))
       end
 
       it "does not change parents meta when children meta changed" do
@@ -127,27 +143,27 @@ describe "Jat::Plugins::JsonApi" do
         child.added_relationship_meta.delete(:related)
         child.added_document_meta.delete(:last)
 
-        assert_equal("foo/1", jat_class.added_object_meta[:self].call)
-        assert_equal("foo/2", jat_class.added_relationship_meta[:related].call)
-        assert_equal("foo/3", jat_class.added_document_meta[:last].call)
+        assert_equal("foo/1", jat_class.added_object_meta[:self].value(nil, nil))
+        assert_equal("foo/2", jat_class.added_relationship_meta[:related].value(nil, nil))
+        assert_equal("foo/3", jat_class.added_document_meta[:last].value(nil, nil))
       end
     end
 
-    describe ".type" do
+    describe ".type, .get_type" do
       it "does not allows to ask for type before type is defined" do
         new_class = Class.new(Jat) { plugin(:json_api) }
 
-        error = assert_raises(Jat::Error) { new_class.type }
+        error = assert_raises(Jat::Error) { new_class.get_type }
         assert_equal "#{new_class} has no defined type", error.message
       end
 
       it "saves and returns current type" do
-        assert_equal :jat, jat_class.type
+        assert_equal :jat, jat_class.get_type
       end
 
       it "symbolizes type" do
         jat_class.type "users"
-        assert_equal :users, jat_class.type
+        assert_equal :users, jat_class.get_type
       end
     end
   end

data/test/lib/jat/plugins/json_api/lib/{params/fields_test.rb → fields_param_parser_test.rb}

@@ -2,8 +2,8 @@
 
 require "test_helper"
 
-describe "Jat::Plugins::JsonApi::Params::Fields" do
-  before { Jat::Plugins.load_plugin(:json_api) }
+describe "Jat::Plugins::JsonApi::FieldsParamParser" do
+  before { Jat::Plugins.find_plugin(:json_api) }
 
   let(:jat_class) do
     Class.new(Jat) do
@@ -16,22 +16,23 @@ describe "Jat::Plugins::JsonApi::Params::Fields" do
     end
   end
 
-  let(:described_class) { Jat::Plugins::JsonApi::Params::Fields }
+  let(:described_class) { jat_class::FieldsParamParser }
 
   it "returns empty hash when parameters not provided" do
-    result = described_class.call(jat_class.allocate, nil)
+    result = described_class.parse(nil)
 
     assert_equal({}, result)
   end
 
   it "returns parsed attributes" do
-    result = described_class.call(jat_class.allocate, a: "a1,a2")
+    result = described_class.parse(a: "a1,a2")
 
     assert_equal({a: %i[a1 a2]}, result)
   end
 
   it "validates provided attributes" do
-    error = assert_raises(Jat::Error) { described_class.call(jat_class.allocate, a: "a1,a2,a3,a4") }
+    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

data/test/lib/jat/plugins/json_api/lib/{params/include_test.rb → include_param_parser_test.rb}

@@ -3,7 +3,7 @@
 require "test_helper"
 
 describe "Jat::Plugins::JsonApi::Params::Include" do
-  before { Jat::Plugins.load_plugin(:json_api) }
+  before { Jat::Plugins.find_plugin(:json_api) }
 
   let(:base_class) { Class.new(Jat) { plugin :json_api } }
   let(:a_serializer) { Class.new(base_class) }
@@ -27,15 +27,15 @@ describe "Jat::Plugins::JsonApi::Params::Include" do
     ser.relationship :b4, serializer: a_serializer
   end
 
-  let(:described_class) { Jat::Plugins::JsonApi::Params::Include }
+  let(:described_class) { a_serializer::IncludeParamParser }
 
   it "returns empty hash when param not provided" do
-    result = described_class.call(a_serializer.allocate, nil)
+    result = described_class.parse(nil)
     assert_equal({}, result)
   end
 
   it "returns typed keys" do
-    result = described_class.call(a_serializer.allocate, "a2.b2,a2.b3,a3.b2.a5,a4")
+    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)
   end
 end

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

@@ -3,115 +3,186 @@
 require "test_helper"
 
 describe "Jat::Plugins::JsonApi::Map" do
-  subject { Jat::Plugins::JsonApi::Map.call(jat) }
+  before { Jat::Plugins.find_plugin(:json_api) }
 
-  let(:jat_class) do
-    Class.new(Jat) do
-      plugin :json_api
-      type :jat
-    end
-  end
-  let(:jat) { jat_class.new(nil, params: {fields: param_fields, include: param_includes}) }
+  let(:described_class) { a::Map }
+  let(:base_class) { Class.new(Jat) { plugin :json_api } }
+
+  let(:a) do
+    ser = Class.new(base_class)
+    ser.type :a
 
-  let(:default_map) { {a: :a1, b: :b1, c: :c1} }
-  let(:includes_map) { {b: :b2, c: :c2} }
-  let(:fields_map) { {c: :c3} }
+    ser.attribute :a1
+    ser.attribute :a2
+    ser.attribute :a3, exposed: false
 
-  before do
-    jat.traversal_map.expects(:exposed).returns(default_map)
+    ser.relationship :b, serializer: b, exposed: true
+    ser.relationship :c, serializer: c
+    ser.relationship :d, serializer: d
+    ser
   end
 
-  describe "when no params given" do
-    let(:param_includes) { nil }
-    let(:param_fields) { nil }
+  let(:b) do
+    ser = Class.new(base_class)
+    ser.type :b
+    ser.attribute :b1
+    ser.attribute :b2
+    ser.attribute :b3, exposed: false
 
-    it "returns map of exposed by default fields" do
-      assert_equal default_map, subject
-    end
+    ser.relationship :c, serializer: c
+    ser.relationship :d, serializer: d
+    ser
   end
 
-  describe "when fields given" do
-    let(:param_includes) { nil }
-    let(:param_fields) { "FIELDS" }
+  let(:c) do
+    ser = Class.new(base_class)
+    ser.type :c
+    ser.attribute :c1
+    ser.attribute :c2
+    ser.attribute :c3, exposed: false
+    ser
+  end
 
-    before do
-      constructor = Jat::Plugins::JsonApi::ConstructTraversalMap.allocate
-      constructor.expects(:to_h).returns(fields_map)
+  let(:d) do
+    ser = Class.new(base_class)
+    ser.type :d
+    ser.attribute :d1
+    ser.attribute :d2
+    ser.attribute :d3, exposed: false
+    ser
+  end
 
-      Jat::Plugins::JsonApi::Params::Fields
-        .expects(:call)
-        .with(jat, "FIELDS")
-        .returns("PARSED_FIELDS")
+  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[]}
+      }
 
-      Jat::Plugins::JsonApi::ConstructTraversalMap
-        .expects(:new)
-        .with(jat_class, :manual, manually_exposed: "PARSED_FIELDS")
-        .returns(constructor)
+      assert_equal expected_result, result
     end
 
-    it "constructs map with default and provided fields" do
-      assert_equal({a: :a1, b: :b1, c: :c3}, subject)
-    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[]}
+      }
 
-  describe "when includes given" do
-    let(:param_includes) { "INCLUDES" }
-    let(:param_fields) { nil }
+      assert_equal expected_result, result
+    end
 
-    before do
-      constructor = Jat::Plugins::JsonApi::ConstructTraversalMap.allocate
-      constructor.expects(:to_h).returns(includes_map)
+    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
 
-      Jat::Plugins::JsonApi::Params::Include
-        .expects(:call)
-        .with(jat, "INCLUDES")
-        .returns("PARSED_INCLUDES")
+    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[]}
+      }
 
-      Jat::Plugins::JsonApi::ConstructTraversalMap
-        .expects(:new)
-        .with(jat_class, :exposed, manually_exposed: "PARSED_INCLUDES")
-        .returns(constructor)
+      assert_equal expected_result, result
     end
 
-    it "constructs map with default and included fields" do
-      assert_equal({a: :a1, b: :b2, c: :c2}, subject)
+    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
 
-  describe "when fields and includes given" do
-    let(:param_fields) { "FIELDS" }
-    let(:param_includes) { "INCLUDES" }
+  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[]}
+      }
 
-    before do
-      constructor1 = Jat::Plugins::JsonApi::ConstructTraversalMap.allocate
-      constructor1.expects(:to_h).returns(fields_map)
+      assert_equal expected_result, result
+    end
 
-      Jat::Plugins::JsonApi::Params::Fields
-        .expects(:call)
-        .with(jat, "FIELDS")
-        .returns("PARSED_FIELDS")
+    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[]}
+      }
 
-      Jat::Plugins::JsonApi::ConstructTraversalMap
-        .expects(:new)
-        .with(jat_class, :manual, manually_exposed: "PARSED_FIELDS")
-        .returns(constructor1)
+      assert_equal expected_result, result
+    end
 
-      constructor2 = Jat::Plugins::JsonApi::ConstructTraversalMap.allocate
-      constructor2.expects(:to_h).returns(includes_map)
+    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[]}
+      }
 
-      Jat::Plugins::JsonApi::Params::Include
-        .expects(:call)
-        .with(jat, "INCLUDES")
-        .returns("PARSED_INCLUDES")
+      assert_equal expected_result, result
+    end
+  end
 
-      Jat::Plugins::JsonApi::ConstructTraversalMap
-        .expects(:new)
-        .with(jat_class, :exposed, manually_exposed: "PARSED_INCLUDES")
-        .returns(constructor2)
+  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 "constructs map with using everything: defaults, includes, fields" do
-      assert_equal({a: :a1, b: :b2, c: :c3}, subject)
+    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