draper 4.0.2 → 4.0.5

data/spec/draper/collection_decorator_spec.rb

@@ -1,291 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples/view_helpers'
-
-module Draper
-  describe CollectionDecorator do
-    it_behaves_like "view helpers", CollectionDecorator.new([])
-
-    describe "#initialize" do
-      describe "options validation" do
-        it "does not raise error on valid options" do
-          valid_options = {with: Decorator, context: {}}
-          expect{CollectionDecorator.new([], valid_options)}.not_to raise_error
-        end
-
-        it "raises error on invalid options" do
-          expect{CollectionDecorator.new([], foo: "bar")}.to raise_error ArgumentError, /Unknown key/
-        end
-      end
-    end
-
-    context "with context" do
-      it "stores the context itself" do
-        context = {some: "context"}
-        decorator = CollectionDecorator.new([], context: context)
-
-        expect(decorator.context).to be context
-      end
-
-      it "passes context to the individual decorators" do
-        context = {some: "context"}
-        decorator = CollectionDecorator.new([Product.new, Product.new], context: context)
-
-        decorator.each do |item|
-          expect(item.context).to be context
-        end
-      end
-    end
-
-    describe "#context=" do
-      it "updates the stored context" do
-        decorator = CollectionDecorator.new([], context: {some: "context"})
-        new_context = {other: "context"}
-
-        decorator.context = new_context
-        expect(decorator.context).to be new_context
-      end
-
-      context "when the collection is already decorated" do
-        it "updates the items' context" do
-          decorator = CollectionDecorator.new([Product.new, Product.new], context: {some: "context"})
-          decorator.decorated_collection # trigger decoration
-          new_context = {other: "context"}
-
-          decorator.context = new_context
-          decorator.each do |item|
-            expect(item.context).to be new_context
-          end
-        end
-      end
-
-      context "when the collection has not yet been decorated" do
-        it "does not trigger decoration" do
-          decorated = CollectionDecorator.new([]).tap(&:to_a)
-          undecorated = CollectionDecorator.new([])
-
-          expect(decorated.instance_variable_defined?(:@decorated_collection)).to be_truthy
-          expect(undecorated.instance_variable_defined?(:@decorated_collection)).to be_falsy
-        end
-
-        it "sets context after decoration is triggered" do
-          decorator = CollectionDecorator.new([Product.new, Product.new], context: {some: "context"})
-          new_context = {other: "context"}
-
-          decorator.context = new_context
-          decorator.each do |item|
-            expect(item.context).to be new_context
-          end
-        end
-      end
-    end
-
-    describe "item decoration" do
-      it "sets decorated items' source models" do
-        collection = [Product.new, Product.new]
-        decorator = CollectionDecorator.new(collection)
-
-        decorator.zip collection do |item, object|
-          expect(item.object).to be object
-        end
-      end
-
-      context "when the :with option was given" do
-        it "uses the :with option" do
-          decorator = CollectionDecorator.new([Product.new], with: OtherDecorator).first
-
-          expect(decorator).to be_decorated_with OtherDecorator
-        end
-      end
-
-      context "when the :with option was not given" do
-        it "infers the item decorator from each item" do
-          decorator = CollectionDecorator.new([double(decorate: :inferred_decorator)]).first
-
-          expect(decorator).to be :inferred_decorator
-        end
-      end
-    end
-
-    describe ".delegate" do
-      protect_class ProductsDecorator
-
-      it "defaults the :to option to :object" do
-        expect(Object).to receive(:delegate).with(:foo, :bar, to: :object)
-        ProductsDecorator.delegate :foo, :bar
-      end
-
-      it "does not overwrite the :to option if supplied" do
-        expect(Object).to receive(:delegate).with(:foo, :bar, to: :baz)
-        ProductsDecorator.delegate :foo, :bar, to: :baz
-      end
-    end
-
-    describe "#find" do
-      it "decorates Enumerable#find" do
-        decorator = CollectionDecorator.new([])
-
-        expect(decorator.decorated_collection).to receive(:find).and_return(:delegated)
-        expect(decorator.find{|p| p.title == "title"}).to be :delegated
-      end
-    end
-
-    describe "#to_ary" do
-      # required for `render @collection` in Rails
-      it "delegates to the decorated collection" do
-        decorator = CollectionDecorator.new([])
-
-        expect(decorator.decorated_collection).to receive(:to_ary).and_return(:delegated)
-        expect(decorator.to_ary).to be :delegated
-      end
-    end
-
-    it "delegates array methods to the decorated collection" do
-      decorator = CollectionDecorator.new([])
-
-      allow(decorator).to receive_message_chain(:decorated_collection, :[]).with(42).and_return(:delegated)
-      expect(decorator[42]).to be :delegated
-    end
-
-    describe "#==" do
-      context "when comparing to a collection decorator with the same object" do
-        it "returns true" do
-          object = [Product.new, Product.new]
-          decorator = CollectionDecorator.new(object)
-          other = ProductsDecorator.new(object)
-
-          expect(decorator == other).to be_truthy
-        end
-      end
-
-      context "when comparing to a collection decorator with a different object" do
-        it "returns false" do
-          decorator = CollectionDecorator.new([Product.new, Product.new])
-          other = ProductsDecorator.new([Product.new, Product.new])
-
-          expect(decorator == other).to be_falsey
-        end
-      end
-
-      context "when comparing to a collection of the same items" do
-        it "returns true" do
-          object = [Product.new, Product.new]
-          decorator = CollectionDecorator.new(object)
-          other = object.dup
-
-          expect(decorator == other).to be_truthy
-        end
-      end
-
-      context "when comparing to a collection of different items" do
-        it "returns false" do
-          decorator = CollectionDecorator.new([Product.new, Product.new])
-          other = [Product.new, Product.new]
-
-          expect(decorator == other).to be_falsey
-        end
-      end
-
-      context "when the decorated collection has been modified" do
-        it "is no longer equal to the object" do
-          object = [Product.new, Product.new]
-          decorator = CollectionDecorator.new(object)
-          other = object.dup
-
-          decorator << Product.new.decorate
-          expect(decorator == other).to be_falsey
-        end
-      end
-    end
-
-    describe "#to_s" do
-      context "when :with option was given" do
-        it "returns a string representation of the collection decorator" do
-          decorator = CollectionDecorator.new(["a", "b", "c"], with: ProductDecorator)
-
-          expect(decorator.to_s).to eq '#<Draper::CollectionDecorator of ProductDecorator for ["a", "b", "c"]>'
-        end
-      end
-
-      context "when :with option was not given" do
-        it "returns a string representation of the collection decorator" do
-          decorator = CollectionDecorator.new(["a", "b", "c"])
-
-          expect(decorator.to_s).to eq '#<Draper::CollectionDecorator of inferred decorators for ["a", "b", "c"]>'
-        end
-      end
-
-      context "for a custom subclass" do
-        it "uses the custom class name" do
-          decorator = ProductsDecorator.new([])
-
-          expect(decorator.to_s).to match(/ProductsDecorator/)
-        end
-      end
-    end
-
-    describe '#object' do
-      it 'returns the underlying collection' do
-        collection = [Product.new]
-        decorator = ProductsDecorator.new(collection)
-
-        expect(decorator.object).to eq collection
-      end
-    end
-
-    describe '#decorated?' do
-      it 'returns true' do
-        decorator = ProductsDecorator.new([Product.new])
-
-        expect(decorator).to be_decorated
-      end
-    end
-
-    describe '#decorated_with?' do
-      it "checks if a decorator has been applied to a collection" do
-        decorator = ProductsDecorator.new([Product.new])
-
-        expect(decorator).to be_decorated_with ProductsDecorator
-        expect(decorator).not_to be_decorated_with OtherDecorator
-      end
-    end
-
-    describe '#kind_of?' do
-      it 'asks the kind of its decorated collection' do
-        decorator = ProductsDecorator.new([])
-        expect(decorator.decorated_collection).to receive(:kind_of?).with(Array).and_return("true")
-        expect(decorator.kind_of?(Array)).to eq "true"
-      end
-
-      context 'when asking the underlying collection returns false' do
-        it 'asks the CollectionDecorator instance itself' do
-          decorator = ProductsDecorator.new([])
-          allow(decorator.decorated_collection).to receive(:kind_of?).with(::Draper::CollectionDecorator).and_return(false)
-          expect(decorator.kind_of?(::Draper::CollectionDecorator)).to be true
-        end
-      end
-    end
-
-    describe '#is_a?' do
-      it 'aliases to #kind_of?' do
-        decorator = ProductsDecorator.new([])
-        expect(decorator.method(:kind_of?)).to eq decorator.method(:is_a?)
-      end
-    end
-
-    describe "#replace" do
-      it "replaces the decorated collection" do
-        decorator = CollectionDecorator.new([Product.new])
-        replacement = [:foo, :bar]
-
-        decorator.replace replacement
-        expect(decorator).to match_array replacement
-      end
-
-      it "returns itself" do
-        decorator = CollectionDecorator.new([Product.new])
-
-        expect(decorator.replace([:foo, :bar])).to be decorator
-      end
-    end
-  end
-end

data/spec/draper/configuration_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-module Draper
-  RSpec.describe Configuration do
-    it 'yields Draper on configure' do
-      Draper.configure { |config| expect(config).to be Draper }
-    end
-
-    describe '#default_controller' do
-      it 'defaults default_controller to ApplicationController' do
-        expect(Draper.default_controller).to be ApplicationController
-      end
-
-      it 'allows customizing default_controller through configure' do
-        default = Draper.default_controller
-
-        Draper.configure do |config|
-          config.default_controller = CustomController
-        end
-
-        expect(Draper.default_controller).to be CustomController
-
-        Draper.default_controller = default
-      end
-    end
-
-    describe '#default_query_methods_strategy' do
-      let!(:default) { Draper.default_query_methods_strategy }
-
-      subject { Draper.default_query_methods_strategy }
-
-      context 'when there is no custom strategy' do
-        it { is_expected.to eq(:active_record) }
-      end
-
-      context 'when using a custom strategy' do
-        before do
-          Draper.configure do |config|
-            config.default_query_methods_strategy = :mongoid
-          end
-        end
-
-        after { Draper.default_query_methods_strategy = default }
-
-        it { is_expected.to eq(:mongoid) }
-      end
-    end
-  end
-end

data/spec/draper/decoratable/equality_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples/decoratable_equality'
-
-module Draper
-  describe Decoratable::Equality do
-    describe "#==" do
-      it_behaves_like "decoration-aware #==", Object.new.extend(Decoratable::Equality)
-    end
-  end
-end

data/spec/draper/decoratable_spec.rb

@@ -1,235 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples/decoratable_equality'
-
-module Draper
-  describe Decoratable do
-    describe "#decorate" do
-      it "returns a decorator for self" do
-        product = Product.new
-        decorator = product.decorate
-
-        expect(decorator).to be_a ProductDecorator
-        expect(decorator.object).to be product
-      end
-
-      it "accepts context" do
-        context = {some: "context"}
-        decorator = Product.new.decorate(context: context)
-
-        expect(decorator.context).to be context
-      end
-
-      it "uses the #decorator_class" do
-        product = Product.new
-        allow(product).to receive_messages decorator_class: OtherDecorator
-
-        expect(product.decorate).to be_an_instance_of OtherDecorator
-      end
-    end
-
-    describe "#applied_decorators" do
-      it "returns an empty list" do
-        expect(Product.new.applied_decorators).to eq []
-      end
-    end
-
-    describe "#decorated_with?" do
-      it "returns false" do
-        expect(Product.new).not_to be_decorated_with Decorator
-      end
-    end
-
-    describe "#decorated?" do
-      it "returns false" do
-        expect(Product.new).not_to be_decorated
-      end
-    end
-
-    describe "#decorator_class?" do
-      it "returns true for decoratable model" do
-        expect(Product.new.decorator_class?).to be_truthy
-      end
-
-      it "returns false for non-decoratable model" do
-        expect(Model.new.decorator_class?).to be_falsey
-      end
-    end
-
-    describe ".decorator_class?" do
-      it "returns true for decoratable model" do
-        expect(Product.decorator_class?).to be_truthy
-      end
-
-      it "returns false for non-decoratable model" do
-        expect(Model.decorator_class?).to be_falsey
-      end
-    end
-
-    describe "#decorator_class" do
-      it "delegates to .decorator_class" do
-        product = Product.new
-
-        expect(Product).to receive(:decorator_class).and_return(:some_decorator)
-        expect(product.decorator_class).to be :some_decorator
-      end
-
-      it "specifies the class that #decorator_class was first called on (superclass)" do
-        person = Person.new
-        expect { person.decorator_class }.to raise_error(Draper::UninferrableDecoratorError, 'Could not infer a decorator for Person.')
-      end
-
-      it "specifies the class that #decorator_class was first called on (subclass)" do
-        child = Child.new
-        expect { child.decorator_class }.to raise_error(Draper::UninferrableDecoratorError, 'Could not infer a decorator for Child.')
-      end
-    end
-
-    describe "#==" do
-      it_behaves_like "decoration-aware #==", Product.new
-    end
-
-    describe "#===" do
-      it "is true when #== is true" do
-        product = Product.new
-
-        expect(product).to receive(:==).and_return(true)
-        expect(product === :anything).to be_truthy
-      end
-
-      it "is false when #== is false" do
-        product = Product.new
-
-        expect(product).to receive(:==).and_return(false)
-        expect(product === :anything).to be_falsey
-      end
-    end
-
-    describe ".====" do
-      it "is true for an instance" do
-        expect(Product === Product.new).to be_truthy
-      end
-
-      it "is true for a derived instance" do
-        expect(Product === Class.new(Product).new).to be_truthy
-      end
-
-      it "is false for an unrelated instance" do
-        expect(Product === Model.new).to be_falsey
-      end
-
-      it "is true for a decorated instance" do
-        decorator = Product.new.decorate
-
-        expect(Product === decorator).to be_truthy
-      end
-
-      it "is true for a decorated derived instance" do
-        decorator = Class.new(Product).new.decorate
-
-        expect(Product === decorator).to be_truthy
-      end
-
-      it "is false for a decorated unrelated instance" do
-        decorator = Other.new.decorate
-
-        expect(Product === decorator).to be_falsey
-      end
-
-      it "is false for a non-decorator which happens to respond to object" do
-        decorator = double(object: Product.new)
-
-        expect(Product === decorator).to be_falsey
-      end
-    end
-
-    describe ".decorate" do
-      it "calls #decorate_collection on .decorator_class" do
-        scoped = [Product.new]
-        allow(Product).to receive(:all).and_return(scoped)
-
-        expect(Product.decorator_class).to receive(:decorate_collection).with(scoped, with: nil).and_return(:decorated_collection)
-        expect(Product.decorate).to be :decorated_collection
-      end
-
-      it "accepts options" do
-        options = {with: ProductDecorator, context: {some: "context"}}
-        allow(Product).to receive(:all).and_return([])
-
-        expect(Product.decorator_class).to receive(:decorate_collection).with([], options)
-        Product.decorate(options)
-      end
-    end
-
-    describe ".decorator_class" do
-      context "for classes" do
-        it "infers the decorator from the class" do
-          expect(Product.decorator_class).to be ProductDecorator
-        end
-
-        context "without a decorator on its own" do
-          it "infers the decorator from a superclass" do
-            expect(SpecialProduct.decorator_class).to be ProductDecorator
-          end
-        end
-      end
-
-      context "for ActiveModel classes" do
-        it "infers the decorator from the model name" do
-          allow(Product).to receive(:model_name){"Other"}
-
-          expect(Product.decorator_class).to be OtherDecorator
-        end
-      end
-
-      context "in a namespace" do
-        context "for classes" do
-          it "infers the decorator from the class" do
-            expect(Namespaced::Product.decorator_class).to be Namespaced::ProductDecorator
-          end
-        end
-
-        context "for ActiveModel classes" do
-          it "infers the decorator from the model name" do
-            allow(Namespaced::Product).to receive(:model_name).and_return("Namespaced::Other")
-
-            expect(Namespaced::Product.decorator_class).to be Namespaced::OtherDecorator
-          end
-        end
-      end
-
-      context "when the decorator contains name error" do
-        it "throws an NameError" do
-          # We imitate ActiveSupport::Autoload behavior here in order to cause lazy NameError exception raising
-          allow_any_instance_of(Module).to receive(:const_missing) { Class.new { any_nonexisting_method_name } }
-
-          expect{Model.decorator_class}.to raise_error { |error| expect(error).to be_an_instance_of(NameError) }
-        end
-      end
-
-      context "when the decorator can't be inferred" do
-        it "throws an UninferrableDecoratorError" do
-          expect{Model.decorator_class}.to raise_error UninferrableDecoratorError
-        end
-      end
-
-      context "when an unrelated NameError is thrown" do
-        it "re-raises that error" do
-          # Not related to safe_constantize behavior, we just want to raise a NameError inside the function
-          allow_any_instance_of(String).to receive(:safe_constantize) { Draper::Base }
-          expect{Product.decorator_class}.to raise_error NameError, /Draper::Base/
-        end
-      end
-
-      context "when an anonymous class is given" do
-        it "infers the decorator from a superclass" do
-          anonymous_class = Class.new(Product) do
-            def self.name
-              to_s
-            end
-          end
-          expect(anonymous_class.decorator_class).to be ProductDecorator
-        end
-      end
-    end
-  end
-end

data/spec/draper/decorated_association_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-module Draper
-  describe DecoratedAssociation do
-    describe "#initialize" do
-      it "accepts valid options" do
-        valid_options = {with: Decorator, scope: :foo, context: {}}
-        expect{DecoratedAssociation.new(Decorator.new(Model.new), :association, valid_options)}.not_to raise_error
-      end
-
-      it "rejects invalid options" do
-        expect{DecoratedAssociation.new(Decorator.new(Model.new), :association, foo: "bar")}.to raise_error ArgumentError, /Unknown key/
-      end
-
-      it "creates a factory" do
-        options = {with: Decorator, context: {foo: "bar"}}
-
-        expect(Factory).to receive(:new).with(options)
-        DecoratedAssociation.new(double, :association, options)
-      end
-
-      describe ":with option" do
-        it "defaults to nil" do
-          expect(Factory).to receive(:new).with(with: nil, context: anything())
-          DecoratedAssociation.new(double, :association, {})
-        end
-      end
-
-      describe ":context option" do
-        it "defaults to the identity function" do
-          expect(Factory).to receive(:new) do |options|
-            options[:context].call(:anything) == :anything
-          end
-          DecoratedAssociation.new(double, :association, {})
-        end
-      end
-    end
-
-    describe "#call" do
-      it "calls the factory" do
-        factory = double
-        allow(Factory).to receive_messages(new: factory)
-        associated = double
-        owner_context = {foo: "bar"}
-        object = double(association: associated)
-        owner = double(object: object, context: owner_context)
-        decorated_association = DecoratedAssociation.new(owner, :association, {})
-        decorated = double
-
-        expect(factory).to receive(:decorate).with(associated, context_args: owner_context).and_return(decorated)
-        expect(decorated_association.call).to be decorated
-      end
-
-      it "memoizes" do
-        factory = double
-        allow(Factory).to receive_messages(new: factory)
-        owner = double(object: double(association: double), context: {})
-        decorated_association = DecoratedAssociation.new(owner, :association, {})
-        decorated = double
-
-        expect(factory).to receive(:decorate).once.and_return(decorated)
-        expect(decorated_association.call).to be decorated
-        expect(decorated_association.call).to be decorated
-      end
-
-      context "when the :scope option was given" do
-        it "applies the scope before decoration" do
-          factory = double
-          allow(Factory).to receive_messages(new: factory)
-          scoped = double
-          object = double(association: double(applied_scope: scoped))
-          owner = double(object: object, context: {})
-          decorated_association = DecoratedAssociation.new(owner, :association, scope: :applied_scope)
-          decorated = double
-
-          expect(factory).to receive(:decorate).with(scoped, anything()).and_return(decorated)
-          expect(decorated_association.call).to be decorated
-        end
-      end
-    end
-  end
-end