jat 0.0.3 → 0.0.8

data/test/lib/jat/plugins/_json_api_activerecord/_json_api_activerecord_test.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Plugins::JsonApiActiverecord" do
-  before do
-    @plugin = Jat::Plugins.load_plugin(:_json_api_activerecord)
-  end
-
-  it "loads other plugins in after_load" do
-    jat_class = Class.new(Jat)
-    jat_class.expects(:plugin).with(:_preloads, foo: :bar)
-    jat_class.expects(:plugin).with(:_activerecord_preloads, foo: :bar)
-
-    Jat::Plugins.after_load(@plugin, jat_class, foo: :bar)
-  end
-
-  describe "ClassMethods" do
-    it "add .jat_preloads method as a delegator to #{@plugin}::Preloads" do
-      jat_class = Class.new(Jat)
-      jat_class.plugin @plugin
-      jat = jat_class.allocate
-
-      @plugin::Preloads.expects(:call).with(jat).returns("RES")
-
-      assert_equal "RES", jat_class.jat_preloads(jat)
-    end
-  end
-end

data/test/lib/jat/plugins/camel_lower/camel_lower_test.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Plugins::CamelLower" do
-  let(:jat_class) do
-    new_class = Class.new(Jat)
-    new_class.plugin(:camel_lower)
-    new_class
-  end
-
-  describe "Attribute" do
-    describe "#name" do
-      it "returns name in camel_lower case" do
-        attribute = jat_class.attribute(:foo)
-        assert :foo, attribute.name
-
-        attribute = jat_class.attribute(:foo_bar)
-        assert :fooBar, attribute.name
-
-        attribute = jat_class.attribute(:foo_bar_bazz)
-        assert :fooBarBazz, attribute.name
-      end
-    end
-  end
-
-  describe "Test responses with simple_api plugin" do
-    before { jat_class.plugin(:simple_api) }
-
-    it "returns attributes in camelLower case" do
-      jat_class.attribute(:foo_bar) { 1 }
-
-      response = jat_class.to_h(true)
-      assert_equal({fooBar: 1}, response)
-    end
-
-    it "accepts fields in camelLower format" do
-      jat_class.attribute(:foo_bar, exposed: false) { 1 }
-
-      response = jat_class.to_h(true, params: {fields: "fooBar"})
-      assert_equal({fooBar: 1}, response)
-    end
-  end
-
-  describe "Test responses with json_api plugin" do
-    before do
-      jat_class.plugin(:json_api)
-      jat_class.type :foo
-      jat_class.attribute(:id) { object }
-    end
-
-    it "returns attributes in camelLower case" do
-      jat_class.attribute(:foo_bar) { 1 }
-
-      assert_equal({fooBar: 1}, jat_class.to_h(true).dig(:data, :attributes))
-    end
-
-    it "accepts `fields` in camelLower format" do
-      jat_class.attribute(:foo_bar, exposed: false) { 1 }
-
-      response = jat_class.to_h(true, params: {fields: {foo: "fooBar"}})
-      assert_equal({fooBar: 1}, response.dig(:data, :attributes))
-    end
-
-    it "accepts `include` in camelLower format" do
-      new_serializer = Class.new(Jat)
-      new_serializer.plugin(:json_api)
-      new_serializer.type :new
-      new_serializer.attribute(:id) { object }
-
-      jat_class.relationship(:foo_bar, serializer: new_serializer) { 1 }
-
-      response = jat_class.to_h(true, params: {include: "fooBar"})
-      response_relationships = response.dig(:data, :relationships).keys
-      assert_includes(response_relationships, :fooBar)
-    end
-  end
-end

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

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Plugins::JsonApi::ConstructTraversalMap" do
-  before { Jat::Plugins.load_plugin(:json_api) }
-
-  let(:described_class) { Jat::Plugins::JsonApi::ConstructTraversalMap }
-  let(:base_class) { Class.new(Jat) { plugin :json_api } }
-
-  let(:a) do
-    ser = Class.new(base_class)
-    ser.type :a
-
-    ser.attribute :a1
-    ser.attribute :a2
-    ser.attribute :a3, exposed: false
-
-    ser.relationship :b, serializer: b
-    ser.relationship :c, serializer: c
-    ser.relationship :d, serializer: d, exposed: true
-    ser
-  end
-
-  let(:b) do
-    ser = Class.new(base_class)
-    ser.type :b
-    ser.attribute :b1
-    ser.attribute :b2
-    ser.attribute :b3, exposed: false
-    ser
-  end
-
-  let(:c) do
-    ser = Class.new(base_class)
-    ser.type :c
-    ser.attribute :c1
-    ser.attribute :c2
-    ser.attribute :c3, exposed: false
-    ser
-  end
-
-  let(:d) do
-    ser = Class.new(base_class)
-    ser.type :d
-    ser.attribute :d1
-    ser.attribute :d2
-    ser.attribute :d3, exposed: false
-    ser
-  end
-
-  it "returns all attributes" do
-    result = described_class.new(a, :all).to_h
-    expected_result = {
-      a: {serializer: a, attributes: %i[a1 a2 a3], relationships: %i[b c d]},
-      b: {serializer: b, attributes: %i[b1 b2 b3], relationships: []},
-      c: {serializer: c, attributes: %i[c1 c2 c3], relationships: []},
-      d: {serializer: d, attributes: %i[d1 d2 d3], relationships: []}
-    }
-
-    assert_equal expected_result, result
-  end
-
-  it "returns exposed attributes" do
-    result = described_class.new(a, :exposed).to_h
-    expected_result = {
-      a: {serializer: a, attributes: %i[a1 a2], relationships: %i[d]},
-      d: {serializer: d, attributes: %i[d1 d2], relationships: []}
-    }
-
-    assert_equal expected_result, result
-  end
-
-  it "returns only manually exposed per-type attributes or exposed by default when no manual type provided" do
-    exposed = {
-      a: %i[a2 a3 c d],
-      c: %i[c2 c3],
-      d: %i[d2 d3]
-    }
-    result = described_class.new(a, :manual, manually_exposed: exposed).to_h
-    expected_result = {
-      a: {serializer: a, attributes: %i[a2 a3], relationships: %i[c d]},
-      c: {serializer: c, attributes: %i[c2 c3], relationships: []},
-      d: {serializer: d, attributes: %i[d2 d3], relationships: []}
-    }
-
-    assert_equal expected_result, result
-  end
-
-  it "returns manually exposed per-type attributes or exposed by default when no manual type provided" do
-    exposed = {
-      a: %i[a2 a3 b c],
-      c: %i[c2 c3]
-    }
-    result = described_class.new(a, :manual, manually_exposed: exposed).to_h
-    expected_result = {
-      a: {serializer: a, attributes: %i[a2 a3], relationships: %i[b c]},
-      b: {serializer: b, attributes: %i[b1 b2], relationships: []},
-      c: {serializer: c, attributes: %i[c2 c3], relationships: []}
-    }
-
-    assert_equal expected_result, result
-  end
-
-  it "returns combined auto-exposed and manualy exposed attributes" do
-    exposed = {
-      a: %i[c],
-      c: %i[c3]
-    }
-    result = described_class.new(a, :exposed, manually_exposed: exposed).to_h
-    expected_result = {
-      a: {serializer: a, attributes: %i[a1 a2], relationships: %i[c d]},
-      c: {serializer: c, attributes: %i[c1 c2 c3], relationships: []},
-      d: {serializer: d, attributes: %i[d1 d2], relationships: []}
-    }
-
-    assert_equal expected_result, result
-  end
-end

data/test/lib/jat/plugins/json_api/lib/params/fields/parse_test.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Plugins::JsonApi::Params::Fields::Parse" do
-  before { Jat::Plugins.load_plugin(:json_api) }
-
-  let(:described_class) { Jat::Plugins::JsonApi::Params::Fields::Parse }
-
-  it "returns empty hash when param not provided" do
-    result = described_class.call(nil)
-    assert_equal({}, result)
-  end
-
-  it "returns hash with parsed keys" do
-    result = described_class.call(a: "a1,a2", b: "b1")
-    assert_equal({a: %i[a1 a2], b: %i[b1]}, result)
-  end
-
-  it "symbolizes types" do
-    result = described_class.call("a" => "a1,a2", "b" => "b1")
-    assert_equal({a: %i[a1 a2], b: %i[b1]}, result)
-  end
-end

data/test/lib/jat/plugins/json_api/lib/params/fields/validate_test.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Plugins::JsonApi::Params::Fields::Validate" do
-  before { Jat::Plugins.load_plugin(:json_api) }
-
-  let(:described_class) { Jat::Plugins::JsonApi::Params::Fields::Validate }
-  let(:base_class) { Class.new(Jat) { plugin :json_api } }
-  let(:a_serializer) { Class.new(base_class) }
-  let(:b_serializer) { Class.new(base_class) }
-
-  before do
-    ser = a_serializer
-    ser.type :a
-    ser.attribute :a1
-    ser.relationship :a2, serializer: b_serializer
-
-    ser = b_serializer
-    ser.type :b
-    ser.attribute :b1
-    ser.relationship :b2, serializer: a_serializer
-  end
-
-  it "does not raises when serializer has all requested keys" do
-    assert described_class.call(a_serializer.allocate, a: %i[a1 a2], b: %i[b1 b2])
-  end
-
-  it "does not raises when requested only fields for nested serializer" do
-    assert described_class.call(a_serializer.allocate, b: %i[b1 b2])
-  end
-
-  it "raises error when some type can not be in response" do
-    error = assert_raises(Jat::Error) { described_class.call(a_serializer.allocate, a: %i[a1 a2], foo: %i[b1 b2]) }
-    assert_equal "#{a_serializer} and its children have no requested type `foo`", error.message
-  end
-
-  it "raises error when some key is not present in main serializer" do
-    error = assert_raises(Jat::Error) { described_class.call(a_serializer.allocate, a: %i[b1]) }
-    assert_equal "#{a_serializer} has no requested attribute or relationship `b1`", error.message
-  end
-
-  it "raises error when some key is not present in nested serializer" do
-    error = assert_raises(Jat::Error) { described_class.call(a_serializer.allocate, a: %i[a1], b: %i[a1]) }
-    assert_equal "#{b_serializer} has no requested attribute or relationship `a1`", error.message
-  end
-end

data/test/lib/jat/plugins/json_api/lib/params/fields_test.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Plugins::JsonApi::Params::Fields" do
-  before { Jat::Plugins.load_plugin(:json_api) }
-
-  let(:jat_class) do
-    Class.new(Jat) do
-      plugin :json_api
-      type :a
-
-      attribute :a1
-      attribute :a2
-      attribute :a3
-    end
-  end
-
-  let(:described_class) { Jat::Plugins::JsonApi::Params::Fields }
-
-  it "returns empty hash when parameters not provided" do
-    result = described_class.call(jat_class.allocate, nil)
-
-    assert_equal({}, result)
-  end
-
-  it "returns parsed attributes" do
-    result = described_class.call(jat_class.allocate, 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") }
-    assert_match(/a4/, error.message)
-  end
-end

data/test/lib/jat/plugins/json_api/lib/params/include/parse_test.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Plugins::JsonApi::Params::Include::Parse" do
-  before { Jat::Plugins.load_plugin(:json_api) }
-
-  let(:described_class) { Jat::Plugins::JsonApi::Params::Include::Parse }
-
-  it "returns empty hash when param not provided" do
-    result = described_class.call(nil)
-
-    assert_equal({}, result)
-  end
-
-  it "returns hash when single element" do
-    result = described_class.call("foo")
-
-    assert_equal({foo: {}}, result)
-  end
-
-  it "returns hash when multiple elements" do
-    result = described_class.call("foo,bar,bazz")
-
-    assert_equal({foo: {}, bar: {}, bazz: {}}, result)
-  end
-
-  it "returns hash when nested elements" do
-    result = described_class.call("foo.bar.bazz")
-
-    assert_equal({foo: {bar: {bazz: {}}}}, result)
-  end
-
-  it "returns hash when multiple nested elements" do
-    result = described_class.call("foo,bar.bazz,bar.bazzz,test.test1.test2,test.test1.test3")
-
-    assert_equal(
-      {
-        foo: {},
-        bar: {bazz: {}, bazzz: {}},
-        test: {test1: {test2: {}, test3: {}}}
-      },
-      result
-    )
-  end
-end

data/test/lib/jat/plugins/json_api/lib/params/include/validate_test.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Plugins::JsonApi::Params::Include::Validate" do
-  before { Jat::Plugins.load_plugin(:json_api) }
-
-  let(:described_class) { Jat::Plugins::JsonApi::Params::Include::Validate }
-
-  let(:base_class) { Class.new(Jat) { plugin :json_api } }
-  let(:a_serializer) { Class.new(base_class) }
-  let(:b_serializer) { Class.new(base_class) }
-
-  before do
-    ser = a_serializer
-    ser.type :a
-    ser.attribute :a1
-    ser.relationship :a2, serializer: b_serializer
-    ser.relationship :a3, serializer: b_serializer
-
-    ser = b_serializer
-    ser.type :b
-    ser.attribute :b1
-    ser.relationship :b2, serializer: a_serializer
-  end
-
-  it "does not raises error when all `include` values are valid" do
-    include_param = {a2: {b2: {a2: {b2: {a2: {}}}}}, a3: {b2: {a2: {b2: {a2: {}}}}}}
-    assert described_class.call(a_serializer, include_param)
-  end
-
-  it "raises error when some key is invalid" do
-    error = assert_raises(Jat::Error) { described_class.call(a_serializer, foo: {}) }
-    assert_equal "#{a_serializer} has no `foo` relationship", error.message
-  end
-
-  it "raises error when some children key is invalid" do
-    error = assert_raises(Jat::Error) { described_class.call(a_serializer, a2: {foo: {}}) }
-    assert_equal "#{b_serializer} has no `foo` relationship", error.message
-  end
-
-  it "raises error when trying to include attribute, not relationship" do
-    error = assert_raises(Jat::Error) { described_class.call(a_serializer, a1: {}) }
-    assert_equal "#{a_serializer} has no `a1` relationship", error.message
-  end
-
-  it "raises error when trying to include not existing nested attribute" do
-    error = assert_raises(Jat::Error) { described_class.call(a_serializer, a2: {b1: {}}) }
-    assert_equal "#{b_serializer} has no `b1` relationship", error.message
-  end
-end

data/test/lib/jat/plugins/json_api/lib/params/include_test.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Plugins::JsonApi::Params::Include" do
-  before { Jat::Plugins.load_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) }
-
-  before do
-    ser = a_serializer
-    ser.type :a
-    ser.attribute :a1
-    ser.relationship :a2, serializer: b_serializer
-    ser.relationship :a3, serializer: b_serializer
-    ser.relationship :a4, serializer: b_serializer
-    ser.relationship :a5, serializer: b_serializer
-    ser.relationship :a6, serializer: b_serializer
-
-    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
-  end
-
-  let(:described_class) { Jat::Plugins::JsonApi::Params::Include }
-
-  it "returns empty hash when param not provided" do
-    result = described_class.call(a_serializer.allocate, 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")
-    assert_equal({a: %i[a2 a3 a5 a4], b: %i[b2 b3]}, result)
-  end
-end

data/test/lib/jat/plugins/json_api/lib/presenters/document_links_presenter_test.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Presenters::DocumentLinksPresenter" do
-  before { Jat::Plugins.load_plugin(:json_api) }
-
-  let(:jat_class) { Class.new(Jat) { plugin :json_api } }
-  let(:presenter_class) { jat_class::DocumentLinksPresenter }
-
-  describe ".jat_class=" do
-    it "assigns @jat_class" do
-      presenter_class.jat_class = :foo
-      assert_equal :foo, presenter_class.instance_variable_get(:@jat_class)
-    end
-  end
-
-  describe ".jat_class" do
-    it "returns self @jat_class" do
-      assert_same jat_class, presenter_class.instance_variable_get(:@jat_class)
-      assert_same jat_class, presenter_class.jat_class
-    end
-  end
-
-  describe ".inspect" do
-    it "returns self name" do
-      assert_equal "#{jat_class}::Presenters::DocumentLinksPresenter", presenter_class.inspect
-    end
-  end
-
-  describe ".add_method" do
-    let(:presenter) { presenter_class.new("OBJECT", "CONTEXT") }
-
-    it "adds method by providing block without variables" do
-      presenter_class.add_method(:foo, proc { [object, context] })
-      assert_equal %w[OBJECT CONTEXT], presenter.foo
-    end
-
-    it "adds method by providing block with one variables" do
-      presenter_class.add_method(:foo, proc { |obj| [obj, object, context] })
-      assert_equal %w[OBJECT OBJECT CONTEXT], presenter.foo
-    end
-
-    it "adds method by providing block with two variables" do
-      presenter_class.add_method(:foo, proc { |obj, ctx| [obj, ctx, object, context] })
-      assert_equal %w[OBJECT CONTEXT OBJECT CONTEXT], presenter.foo
-    end
-
-    it "raises error when block has more than two variables" do
-      error = assert_raises(Jat::Error) { presenter_class.add_method(:foo, proc { |_a, _b, _c| }) }
-      assert_equal "Invalid block arguments count", error.message
-    end
-
-    it "redefines_method" do
-      presenter_class.add_method(:foo, proc { "OLD" })
-      presenter_class.add_method(:foo, proc { "NEW" })
-      assert_equal "NEW", presenter.foo
-    end
-  end
-
-  describe "#initialize" do
-    it "initializes object presenter with provided object and context" do
-      presenter = presenter_class.new("OBJ", "CTX")
-
-      assert_equal "OBJ", presenter.object
-      assert_equal "CTX", presenter.context
-    end
-  end
-end

data/test/lib/jat/plugins/json_api/lib/presenters/document_meta_presenter_test.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Presenters::DocumentMetaPresenter" do
-  before { Jat::Plugins.load_plugin(:json_api) }
-
-  let(:jat_class) { Class.new(Jat) { plugin :json_api } }
-  let(:presenter_class) { jat_class::DocumentMetaPresenter }
-
-  describe ".jat_class=" do
-    it "assigns @jat_class" do
-      presenter_class.jat_class = :foo
-      assert_equal :foo, presenter_class.instance_variable_get(:@jat_class)
-    end
-  end
-
-  describe ".jat_class" do
-    it "returns self @jat_class" do
-      assert_same jat_class, presenter_class.instance_variable_get(:@jat_class)
-      assert_same jat_class, presenter_class.jat_class
-    end
-  end
-
-  describe ".inspect" do
-    it "returns self name" do
-      assert_equal "#{jat_class}::Presenters::DocumentMetaPresenter", presenter_class.inspect
-    end
-  end
-
-  describe ".add_method" do
-    let(:presenter) { presenter_class.new("OBJECT", "CONTEXT") }
-
-    it "adds method by providing block without variables" do
-      presenter_class.add_method(:foo, proc { [object, context] })
-      assert_equal %w[OBJECT CONTEXT], presenter.foo
-    end
-
-    it "adds method by providing block with one variables" do
-      presenter_class.add_method(:foo, proc { |obj| [obj, object, context] })
-      assert_equal %w[OBJECT OBJECT CONTEXT], presenter.foo
-    end
-
-    it "adds method by providing block with two variables" do
-      presenter_class.add_method(:foo, proc { |obj, ctx| [obj, ctx, object, context] })
-      assert_equal %w[OBJECT CONTEXT OBJECT CONTEXT], presenter.foo
-    end
-
-    it "raises error when block has more than two variables" do
-      error = assert_raises(Jat::Error) { presenter_class.add_method(:foo, proc { |_a, _b, _c| }) }
-      assert_equal "Invalid block arguments count", error.message
-    end
-
-    it "redefines_method" do
-      presenter_class.add_method(:foo, proc { "OLD" })
-      presenter_class.add_method(:foo, proc { "NEW" })
-      assert_equal "NEW", presenter.foo
-    end
-  end
-
-  describe "#initialize" do
-    it "initializes object presenter with provided object and context" do
-      presenter = presenter_class.new("OBJ", "CTX")
-
-      assert_equal "OBJ", presenter.object
-      assert_equal "CTX", presenter.context
-    end
-  end
-end

data/test/lib/jat/plugins/json_api/lib/presenters/jsonapi_presenter_test.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-describe "Jat::Presenters::JsonapiPresenter" do
-  before { Jat::Plugins.load_plugin(:json_api) }
-
-  let(:jat_class) { Class.new(Jat) { plugin :json_api } }
-  let(:presenter_class) { jat_class::JsonapiPresenter }
-
-  describe ".jat_class=" do
-    it "assigns @jat_class" do
-      presenter_class.jat_class = :foo
-      assert_equal :foo, presenter_class.instance_variable_get(:@jat_class)
-    end
-  end
-
-  describe ".jat_class" do
-    it "returns self @jat_class" do
-      assert_same jat_class, presenter_class.instance_variable_get(:@jat_class)
-      assert_same jat_class, presenter_class.jat_class
-    end
-  end
-
-  describe ".inspect" do
-    it "returns self name" do
-      assert_equal "#{jat_class}::Presenters::JsonapiPresenter", presenter_class.inspect
-    end
-  end
-
-  describe ".add_method" do
-    let(:presenter) { presenter_class.new("OBJECT", "CONTEXT") }
-
-    it "adds method by providing block without variables" do
-      presenter_class.add_method(:foo, proc { [object, context] })
-      assert_equal %w[OBJECT CONTEXT], presenter.foo
-    end
-
-    it "adds method by providing block with one variables" do
-      presenter_class.add_method(:foo, proc { |obj| [obj, object, context] })
-      assert_equal %w[OBJECT OBJECT CONTEXT], presenter.foo
-    end
-
-    it "adds method by providing block with two variables" do
-      presenter_class.add_method(:foo, proc { |obj, ctx| [obj, ctx, object, context] })
-      assert_equal %w[OBJECT CONTEXT OBJECT CONTEXT], presenter.foo
-    end
-
-    it "raises error when block has more than two variables" do
-      error = assert_raises(Jat::Error) { presenter_class.add_method(:foo, proc { |_a, _b, _c| }) }
-      assert_equal "Invalid block arguments count", error.message
-    end
-
-    it "redefines_method" do
-      presenter_class.add_method(:foo, proc { "OLD" })
-      presenter_class.add_method(:foo, proc { "NEW" })
-      assert_equal "NEW", presenter.foo
-    end
-  end
-
-  describe "#initialize" do
-    it "initializes object presenter with provided object and context" do
-      presenter = presenter_class.new("OBJ", "CTX")
-
-      assert_equal "OBJ", presenter.object
-      assert_equal "CTX", presenter.context
-    end
-  end
-end