kotovalexarian-likes-github/draper
1
0
Fork 0
mirror of https://github.com/drapergem/draper synced 2023-03-27 23:21:17 -04:00
Code Releases Activity

update rspec syntax to the new one

Browse source
This commit is contained in:
Luciano Sousa 2016-06-09 18:49:42 -03:00
parent 793ead5d5f
commit 447816cf10
14 changed files with 163 additions and 163 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
spec/draper/collection_decorator_spec.rb
View file

@ -63,7 +63,7 @@ module Draper
it "does not trigger decoration" do
decorator = CollectionDecorator.new([])
decorator.should_not_receive(:decorated_collection)
expect(decorator).not_to receive(:decorated_collection)
decorator.context = {other: "context"}
end
@ -110,12 +110,12 @@ module Draper
protect_class ProductsDecorator
it "defaults the :to option to :object" do
Object.should_receive(:delegate).with(:foo, :bar, to: :object)
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
Object.should_receive(:delegate).with(:foo, :bar, to: :baz)
expect(Object).to receive(:delegate).with(:foo, :bar, to: :baz)
ProductsDecorator.delegate :foo, :bar, to: :baz
end
end
@ -125,7 +125,7 @@ module Draper
it "decorates Enumerable#find" do
decorator = CollectionDecorator.new([])
decorator.decorated_collection.should_receive(:find).and_return(:delegated)
expect(decorator.decorated_collection).to receive(:find).and_return(:delegated)
expect(decorator.find{|p| p.title == "title"}).to be :delegated
end
end
@ -136,7 +136,7 @@ module Draper
found = double(decorate: :decorated)
decorator = CollectionDecorator.new(object)
object.should_receive(:find).and_return(found)
expect(object).to receive(:find).and_return(found)
ActiveSupport::Deprecation.silence do
expect(decorator.find(1)).to be :decorated
end
@ -149,7 +149,7 @@ module Draper
it "delegates to the decorated collection" do
decorator = CollectionDecorator.new([])
decorator.decorated_collection.should_receive(:to_ary).and_return(:delegated)
expect(decorator.decorated_collection).to receive(:to_ary).and_return(:delegated)
expect(decorator.to_ary).to be :delegated
end
end
@ -157,7 +157,7 @@ module Draper
it "delegates array methods to the decorated collection" do
decorator = CollectionDecorator.new([])
decorator.decorated_collection.should_receive(:[]).with(42).and_return(:delegated)
allow(decorator).to receive_message_chain(:decorated_collection, :[]).with(42).and_return(:delegated)
expect(decorator[42]).to be :delegated
end
@ -267,14 +267,14 @@ module Draper
describe '#kind_of?' do
it 'asks the kind of its decorated collection' do
decorator = ProductsDecorator.new([])
decorator.decorated_collection.should_receive(:kind_of?).with(Array).and_return("true")
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([])
decorator.decorated_collection.stub(:kind_of?).with(::Draper::CollectionDecorator).and_return(false)
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

20
spec/draper/decoratable_spec.rb
View file

@ -22,7 +22,7 @@ module Draper
it "uses the #decorator_class" do
product = Product.new
product.stub decorator_class: OtherDecorator
allow(product).to receive_messages decorator_class: OtherDecorator
expect(product.decorate).to be_an_instance_of OtherDecorator
end
@ -70,7 +70,7 @@ module Draper
it "delegates to .decorator_class" do
product = Product.new
Product.should_receive(:decorator_class).and_return(:some_decorator)
expect(Product).to receive(:decorator_class).and_return(:some_decorator)
expect(product.decorator_class).to be :some_decorator
end
end
@ -83,14 +83,14 @@ module Draper
it "is true when #== is true" do
product = Product.new
product.should_receive(:==).and_return(true)
expect(product).to receive(:==).and_return(true)
expect(product === :anything).to be_truthy
end
it "is false when #== is false" do
product = Product.new
product.should_receive(:==).and_return(false)
expect(product).to receive(:==).and_return(false)
expect(product === :anything).to be_falsey
end
end
@ -132,17 +132,17 @@ module Draper
it "calls #decorate_collection on .decorator_class" do
scoped = [Product.new]
Product.stub scoping_method => scoped
allow(Product).to receive_messages scoping_method => scoped
Product.decorator_class.should_receive(:decorate_collection).with(scoped, with: nil).and_return(:decorated_collection)
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"}}
Product.stub scoping_method => []
allow(Product).to receive_messages scoping_method => []
Product.decorator_class.should_receive(:decorate_collection).with([], options)
expect(Product.decorator_class).to receive(:decorate_collection).with([], options)
Product.decorate(options)
end
end
@ -177,7 +177,7 @@ module Draper
context "for ActiveModel classes" do
it "infers the decorator from the model name" do
Namespaced::Product.stub(:model_name).and_return("Namespaced::Other")
allow(Namespaced::Product).to receive(:model_name).and_return("Namespaced::Other")
expect(Namespaced::Product.decorator_class).to be Namespaced::OtherDecorator
end
@ -192,7 +192,7 @@ module Draper
context "when an unrelated NameError is thrown" do
it "re-raises that error" do
String.any_instance.stub(:constantize) { Draper::Base }
allow_any_instance_of(String).to receive(:constantize) { Draper::Base }
expect{Product.decorator_class}.to raise_error NameError, /Draper::Base/
end
end

18
spec/draper/decorated_association_spec.rb
View file

@ -16,20 +16,20 @@ module Draper
it "creates a factory" do
options = {with: Decorator, context: {foo: "bar"}}
Factory.should_receive(:new).with(options)
expect(Factory).to receive(:new).with(options)
DecoratedAssociation.new(double, :association, options)
end
describe ":with option" do
it "defaults to nil" do
Factory.should_receive(:new).with(with: nil, context: anything())
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
Factory.should_receive(:new) do |options|
expect(Factory).to receive(:new) do |options|
options[:context].call(:anything) == :anything
end
DecoratedAssociation.new(double, :association, {})
@ -40,7 +40,7 @@ module Draper
describe "#call" do
it "calls the factory" do
factory = double
Factory.stub new: factory
allow(Factory).to receive_messages(new: factory)
associated = double
owner_context = {foo: "bar"}
object = double(association: associated)
@ -48,18 +48,18 @@ module Draper
decorated_association = DecoratedAssociation.new(owner, :association, {})
decorated = double
factory.should_receive(:decorate).with(associated, context_args: owner_context).and_return(decorated)
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
Factory.stub new: factory
allow(Factory).to receive_messages(new: factory)
owner = double(object: double(association: double), context: {})
decorated_association = DecoratedAssociation.new(owner, :association, {})
decorated = double
factory.should_receive(:decorate).once.and_return(decorated)
expect(factory).to receive(:decorate).once.and_return(decorated)
expect(decorated_association.call).to be decorated
expect(decorated_association.call).to be decorated
end
@ -67,14 +67,14 @@ module Draper
context "when the :scope option was given" do
it "applies the scope before decoration" do
factory = double
Factory.stub new: factory
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
factory.should_receive(:decorate).with(scoped, anything()).and_return(decorated)
expect(factory).to receive(:decorate).with(scoped, anything()).and_return(decorated)
expect(decorated_association.call).to be decorated
end
end

12
spec/draper/decorates_assigned_spec.rb
View file

@ -28,14 +28,14 @@ module Draper
end
it "creates a factory" do
Factory.should_receive(:new).once
allow(Factory).to receive(:new).once
controller_class.decorates_assigned :article, :author
end
it "passes options to the factory" do
options = {foo: "bar"}
Factory.should_receive(:new).with(options)
allow(Factory).to receive(:new).with(options)
controller_class.decorates_assigned :article, :author, options
end
@ -43,24 +43,24 @@ module Draper
it "decorates the instance variable" do
object = double
factory = double
Factory.stub new: factory
allow(Factory).to receive_messages(new: factory)
controller_class.decorates_assigned :article
controller = controller_class.new
controller.instance_variable_set "@article", object
factory.should_receive(:decorate).with(object, context_args: controller).and_return(:decorated)
expect(factory).to receive(:decorate).with(object, context_args: controller).and_return(:decorated)
expect(controller.article).to be :decorated
end
it "memoizes" do
factory = double
Factory.stub new: factory
allow(Factory).to receive_messages(new: factory)
controller_class.decorates_assigned :article
controller = controller_class.new
factory.should_receive(:decorate).once
expect(factory).to receive(:decorate).once
controller.article
controller.article
end

72
spec/draper/decorator_spec.rb
View file

@ -73,7 +73,7 @@ module Draper
decorated = OtherDecorator.new(Decorator.new(Model.new))
warning_message = nil
Object.any_instance.stub(:warn) { |instance, message| warning_message = message }
allow_any_instance_of(Object).to receive(:warn) { |instance, message| warning_message = message }
expect{Decorator.new(decorated)}.to change{warning_message}
expect(warning_message).to start_with "Reapplying Draper::Decorator"
@ -82,7 +82,7 @@ module Draper
it "decorates anyway" do
decorated = OtherDecorator.new(Decorator.new(Model.new))
Object.any_instance.stub(:warn)
allow_any_instance_of(Object).to receive(:warn)
redecorated = Decorator.decorate(decorated)
expect(redecorated.object).to be decorated
@ -102,7 +102,7 @@ module Draper
describe ".decorate_collection" do
describe "options validation" do
before { CollectionDecorator.stub(:new) }
before { allow(CollectionDecorator).to receive(:new) }
it "does not raise error on valid options" do
valid_options = {with: OtherDecorator, context: {}}
@ -118,14 +118,14 @@ module Draper
it "creates a CollectionDecorator using itself for each item" do
object = [Model.new]
CollectionDecorator.should_receive(:new).with(object, with: Decorator)
expect(CollectionDecorator).to receive(:new).with(object, with: Decorator)
Decorator.decorate_collection(object)
end
it "passes options to the collection decorator" do
options = {with: OtherDecorator, context: {some: "context"}}
CollectionDecorator.should_receive(:new).with([], options)
expect(CollectionDecorator).to receive(:new).with([], options)
Decorator.decorate_collection([], options)
end
end
@ -134,21 +134,21 @@ module Draper
it "creates a custom collection decorator using itself for each item" do
object = [Model.new]
ProductsDecorator.should_receive(:new).with(object, with: ProductDecorator)
expect(ProductsDecorator).to receive(:new).with(object, with: ProductDecorator)
ProductDecorator.decorate_collection(object)
end
it "passes options to the collection decorator" do
options = {with: OtherDecorator, context: {some: "context"}}
ProductsDecorator.should_receive(:new).with([], options)
expect(ProductsDecorator).to receive(:new).with([], options)
ProductDecorator.decorate_collection([], options)
end
end
context "when a NameError is thrown" do
it "re-raises that error" do
String.any_instance.stub(:constantize) { Draper::DecoratedEnumerableProxy }
allow_any_instance_of(String).to receive(:constantize) { Draper::DecoratedEnumerableProxy }
expect{ProductDecorator.decorate_collection([])}.to raise_error NameError, /Draper::DecoratedEnumerableProxy/
end
end
@ -208,7 +208,7 @@ module Draper
context "when an unrelated NameError is thrown" do
it "re-raises that error" do
String.any_instance.stub(:constantize) { SomethingThatDoesntExist }
allow_any_instance_of(String).to receive(:constantize) { SomethingThatDoesntExist }
expect{ProductDecorator.object_class}.to raise_error NameError, /SomethingThatDoesntExist/
end
end
@ -221,19 +221,19 @@ module Draper
describe ".object_class?" do
it "returns truthy when .object_class is set" do
Decorator.stub(:object_class).and_return(Model)
allow(Decorator).to receive(:object_class).and_return(Model)
expect(Decorator.object_class?).to be_truthy
end
it "returns false when .object_class is not inferrable" do
Decorator.stub(:object_class).and_raise(UninferrableSourceError.new(Decorator))
allow(Decorator).to receive(:object_class).and_raise(UninferrableSourceError.new(Decorator))
expect(Decorator.object_class?).to be_falsey
end
it "is aliased to .source_class?" do
Decorator.stub(:object_class).and_return(Model)
allow(Decorator).to receive(:object_class).and_return(Model)
expect(Decorator.source_class?).to be_truthy
end
@ -243,7 +243,7 @@ module Draper
protect_class Decorator
describe "options validation" do
before { DecoratedAssociation.stub(:new).and_return(->{}) }
before { allow(DecoratedAssociation).to receive(:new).and_return(->{}) }
it "does not raise error on valid options" do
valid_options = {with: Class, scope: :sorted, context: {}}
@ -261,7 +261,7 @@ module Draper
Decorator.decorates_association :children, options
decorator = Decorator.new(Model.new)
DecoratedAssociation.should_receive(:new).with(decorator, :children, options).and_return(->{})
expect(DecoratedAssociation).to receive(:new).with(decorator, :children, options).and_return(->{})
decorator.children
end
@ -269,7 +269,7 @@ module Draper
Decorator.decorates_association :children
decorator = Decorator.new(Model.new)
DecoratedAssociation.should_receive(:new).once.and_return(->{})
expect(DecoratedAssociation).to receive(:new).once.and_return(->{})
decorator.children
decorator.children
end
@ -278,9 +278,9 @@ module Draper
Decorator.decorates_association :children
decorator = Decorator.new(Model.new)
decorated_association = ->{}
DecoratedAssociation.stub(:new).and_return(decorated_association)
allow(DecoratedAssociation).to receive(:new).and_return(decorated_association)
decorated_association.should_receive(:call).and_return(:decorated)
expect(decorated_association).to receive(:call).and_return(:decorated)
expect(decorator.children).to be :decorated
end
end
@ -290,16 +290,16 @@ module Draper
protect_class Decorator
it "decorates each of the associations" do
Decorator.should_receive(:decorates_association).with(:friends, {})
Decorator.should_receive(:decorates_association).with(:enemies, {})
expect(Decorator).to receive(:decorates_association).with(:friends, {})
expect(Decorator).to receive(:decorates_association).with(:enemies, {})
Decorator.decorates_associations :friends, :enemies
end
it "dispatches options" do
options = {with: Class.new, scope: :foo, context: {}}
Decorator.should_receive(:decorates_association).with(:friends, options)
Decorator.should_receive(:decorates_association).with(:enemies, options)
expect(Decorator).to receive(:decorates_association).with(:friends, options)
expect(Decorator).to receive(:decorates_association).with(:enemies, options)
Decorator.decorates_associations :friends, :enemies, options
end
end
@ -480,7 +480,7 @@ module Draper
describe "#attributes" do
it "returns only the object's attributes that are implemented by the decorator" do
decorator = Decorator.new(double(attributes: {foo: "bar", baz: "qux"}))
decorator.stub(:foo)
allow(decorator).to receive(:foo)
expect(decorator.attributes).to eq({foo: "bar"})
end
@ -488,7 +488,7 @@ module Draper
describe ".model_name" do
it "delegates to the source class" do
Decorator.stub object_class: double(model_name: :delegated)
allow(Decorator).to receive(:object_class).and_return(double(model_name: :delegated))
expect(Decorator.model_name).to be :delegated
end
@ -514,7 +514,7 @@ module Draper
decorator = Decorator.new(object)
other = double(object: Model.new)
object.should_receive(:==).with(other).and_return(true)
expect(object).to receive(:==).with(other).and_return(true)
expect(decorator == other).to be_truthy
end
@ -523,7 +523,7 @@ module Draper
decorator = Decorator.new(object)
other = double(object: Model.new)
object.should_receive(:==).with(other).and_return(false)
expect(object).to receive(:==).with(other).and_return(false)
expect(decorator == other).to be_falsey
end
end
@ -538,7 +538,7 @@ module Draper
it "is false when #== is false" do
decorator = Decorator.new(Model.new)
decorator.stub(:==).with(:anything).and_return(false)
allow(decorator).to receive(:==).with(:anything).and_return(false)
expect(decorator === :anything).to be_falsey
end
@ -574,12 +574,12 @@ module Draper
protect_class Decorator
it "defaults the :to option to :object" do
Object.should_receive(:delegate).with(:foo, :bar, to: :object)
expect(Object).to receive(:delegate).with(:foo, :bar, to: :object)
Decorator.delegate :foo, :bar
end
it "does not overwrite the :to option if supplied" do
Object.should_receive(:delegate).with(:foo, :bar, to: :baz)
expect(Object).to receive(:delegate).with(:foo, :bar, to: :baz)
Decorator.delegate :foo, :bar, to: :baz
end
end
@ -614,7 +614,7 @@ module Draper
it "passes blocks to delegated methods" do
object = Model.new
object.stub(:hello_world) { |*args, &block| block.call }
allow(object).to receive(:hello_world) { |*args, &block| block.call }
decorator = Decorator.new(object)
expect(decorator.hello_world{:yielded}).to be :yielded
@ -628,7 +628,7 @@ module Draper
it "delegates already-delegated methods" do
object = Class.new{ delegate :bar, to: :foo }.new
object.stub foo: double(bar: :delegated)
allow(object).to receive_messages foo: double(bar: :delegated)
decorator = Decorator.new(object)
expect(decorator.bar).to be :delegated
@ -660,14 +660,14 @@ module Draper
context "with a source class" do
it "delegates methods that exist on the source class" do
object_class = Class.new
object_class.stub hello_world: :delegated
Decorator.stub object_class: object_class
allow(object_class).to receive_messages hello_world: :delegated
allow(Decorator).to receive_messages object_class: object_class
expect(Decorator.hello_world).to be :delegated
end
it "does not delegate methods that do not exist on the source class" do
Decorator.stub object_class: Class.new
allow(Decorator).to receive_messages object_class: Class.new
expect{Decorator.hello_world}.to raise_error NoMethodError
end
@ -721,13 +721,13 @@ module Draper
context "with a source class" do
it "returns true for its own class methods" do
Decorator.class_eval{def self.hello_world; end}
Decorator.stub object_class: Class.new
allow(Decorator).to receive_messages object_class: Class.new
expect(Decorator).to respond_to :hello_world
end
it "returns true for the source's class methods" do
Decorator.stub object_class: double(hello_world: :delegated)
allow(Decorator).to receive_messages object_class: double(hello_world: :delegated)
expect(Decorator).to respond_to :hello_world
end
@ -745,7 +745,7 @@ module Draper
describe ".respond_to_missing?" do
it "allows .method to be called on delegated class methods" do
Decorator.stub object_class: double(hello_world: :delegated)
allow(Decorator).to receive_messages object_class: double(hello_world: :delegated)
expect(Decorator.method(:hello_world)).not_to be_nil
end

48
spec/draper/factory_spec.rb
View file

@ -27,7 +27,7 @@ module Draper
factory = Factory.new
worker = ->(*){ :decorated }
Factory::Worker.should_receive(:new).and_return(worker)
expect(Factory::Worker).to receive(:new).and_return(worker)
expect(factory.decorate(double)).to be :decorated
end
@ -35,7 +35,7 @@ module Draper
factory = Factory.new
object = double
Factory::Worker.should_receive(:new).with(anything(), object).and_return(->(*){})
expect(Factory::Worker).to receive(:new).with(anything(), object).and_return(->(*){})
factory.decorate(object)
end
@ -44,7 +44,7 @@ module Draper
decorator_class = double
factory = Factory.new(with: decorator_class)
Factory::Worker.should_receive(:new).with(decorator_class, anything()).and_return(->(*){})
expect(Factory::Worker).to receive(:new).with(decorator_class, anything()).and_return(->(*){})
factory.decorate(double)
end
end
@ -53,7 +53,7 @@ module Draper
it "passes nil to the worker" do
factory = Factory.new
Factory::Worker.should_receive(:new).with(nil, anything()).and_return(->(*){})
expect(Factory::Worker).to receive(:new).with(nil, anything()).and_return(->(*){})
factory.decorate(double)
end
end
@ -61,10 +61,10 @@ module Draper
it "passes options to the call" do
factory = Factory.new
worker = ->(*){}
Factory::Worker.stub new: worker
allow(Factory::Worker).to receive(:new).and_return(worker)
options = {foo: "bar"}
worker.should_receive(:call).with(options)
allow(worker).to receive(:call).with(options)
factory.decorate(double, options)
end
@ -72,18 +72,18 @@ module Draper
it "sets the passed context" do
factory = Factory.new(context: {foo: "bar"})
worker = ->(*){}
Factory::Worker.stub new: worker
allow(Factory::Worker).to receive_messages new: worker
worker.should_receive(:call).with(baz: "qux", context: {foo: "bar"})
expect(worker).to receive(:call).with(baz: "qux", context: {foo: "bar"})
factory.decorate(double, {baz: "qux"})
end
it "is overridden by explicitly-specified context" do
factory = Factory.new(context: {foo: "bar"})
worker = ->(*){}
Factory::Worker.stub new: worker
allow(Factory::Worker).to receive_messages new: worker
worker.should_receive(:call).with(context: {baz: "qux"})
expect(worker).to receive(:call).with(context: {baz: "qux"})
factory.decorate(double, context: {baz: "qux"})
end
end
@ -99,9 +99,9 @@ module Draper
options = {foo: "bar"}
worker = Factory::Worker.new(double, object)
decorator = ->(*){}
allow(worker).to receive(:decorator){ decorator }
allow(worker).to receive(:decorator){ decorator }
decorator.should_receive(:call).with(object, options).and_return(:decorated)
allow(decorator).to receive(:call).with(object, options).and_return(:decorated)
expect(worker.call(options)).to be :decorated
end
@ -109,29 +109,29 @@ module Draper
it "calls it" do
worker = Factory::Worker.new(double, double)
decorator = ->(*){}
worker.stub decorator: decorator
allow(worker).to receive_messages decorator: decorator
context = {foo: "bar"}
decorator.should_receive(:call).with(anything(), context: context)
expect(decorator).to receive(:call).with(anything(), context: context)
worker.call(context: ->{ context })
end
it "receives arguments from the :context_args option" do
worker = Factory::Worker.new(double, double)
worker.stub decorator: ->(*){}
allow(worker).to receive_messages decorator: ->(*){}
context = ->{}
context.should_receive(:call).with(:foo, :bar)
expect(context).to receive(:call).with(:foo, :bar)
worker.call(context: context, context_args: [:foo, :bar])
end
it "wraps non-arrays passed to :context_args" do
worker = Factory::Worker.new(double, double)
worker.stub decorator: ->(*){}
allow(worker).to receive_messages decorator: ->(*){}
context = ->{}
hash = {foo: "bar"}
context.should_receive(:call).with(hash)
expect(context).to receive(:call).with(hash)
worker.call(context: context, context_args: hash)
end
end
@ -140,10 +140,10 @@ module Draper
it "doesn't call it" do
worker = Factory::Worker.new(double, double)
decorator = ->(*){}
worker.stub decorator: decorator
allow(worker).to receive_messages decorator: decorator
context = {foo: "bar"}
decorator.should_receive(:call).with(anything(), context: context)
expect(decorator).to receive(:call).with(anything(), context: context)
worker.call(context: context)
end
end
@ -151,9 +151,9 @@ module Draper
it "does not pass the :context_args option to the decorator" do
worker = Factory::Worker.new(double, double)
decorator = ->(*){}
worker.stub decorator: decorator
allow(worker).to receive_messages decorator: decorator
decorator.should_receive(:call).with(anything(), foo: "bar")
expect(decorator).to receive(:call).with(anything(), foo: "bar")
worker.call(foo: "bar", context_args: [])
end
end
@ -176,7 +176,7 @@ module Draper
options = {foo: "bar"}
worker = Factory::Worker.new(nil, object)
object.should_receive(:decorate).with(options).and_return(:decorated)
expect(object).to receive(:decorate).with(options).and_return(:decorated)
expect(worker.decorator.call(object, options)).to be :decorated
end
end
@ -231,7 +231,7 @@ module Draper
allow(object).to receive(:decorate){ nil }
worker = Factory::Worker.new(nil, object)
decorator_class.should_receive(:decorate_collection).with(object, foo: "bar", with: nil).and_return(:decorated)
expect(decorator_class).to receive(:decorate_collection).with(object, foo: "bar", with: nil).and_return(:decorated)
expect(worker.decorator.call(object, foo: "bar")).to be :decorated
end
end

42
spec/draper/finders_spec.rb
View file

@ -7,20 +7,20 @@ module Draper
describe ".find" do
it "proxies to the model class" do
Product.should_receive(:find).with(1)
expect(Product).to receive(:find).with(1)
ProductDecorator.find(1)
end
it "decorates the result" do
found = Product.new
Product.stub(:find).and_return(found)
allow(Product).to receive(:find).and_return(found)
decorator = ProductDecorator.find(1)
expect(decorator).to be_a ProductDecorator
expect(decorator.object).to be found
end
it "passes context to the decorator" do
Product.stub(:find)
allow(Product).to receive(:find)
context = {some: "context"}
decorator = ProductDecorator.find(1, context: context)
@ -30,40 +30,40 @@ module Draper
describe ".find_by_(x)" do
it "proxies to the model class" do
Product.should_receive(:find_by_name).with("apples")
expect(Product).to receive(:find_by_name).with("apples")
ProductDecorator.find_by_name("apples")
end
it "decorates the result" do
found = Product.new
Product.stub(:find_by_name).and_return(found)
allow(Product).to receive(:find_by_name).and_return(found)
decorator = ProductDecorator.find_by_name("apples")
expect(decorator).to be_a ProductDecorator
expect(decorator.object).to be found
end
it "proxies complex ProductDecorators" do
Product.should_receive(:find_by_name_and_size).with("apples", "large")
expect(Product).to receive(:find_by_name_and_size).with("apples", "large")
ProductDecorator.find_by_name_and_size("apples", "large")
end
it "proxies find_last_by_(x) ProductDecorators" do
Product.should_receive(:find_last_by_name_and_size).with("apples", "large")
expect(Product).to receive(:find_last_by_name_and_size).with("apples", "large")
ProductDecorator.find_last_by_name_and_size("apples", "large")
end
it "proxies find_or_initialize_by_(x) ProductDecorators" do
Product.should_receive(:find_or_initialize_by_name_and_size).with("apples", "large")
expect(Product).to receive(:find_or_initialize_by_name_and_size).with("apples", "large")
ProductDecorator.find_or_initialize_by_name_and_size("apples", "large")
end
it "proxies find_or_create_by_(x) ProductDecorators" do
Product.should_receive(:find_or_create_by_name_and_size).with("apples", "large")
expect(Product).to receive(:find_or_create_by_name_and_size).with("apples", "large")
ProductDecorator.find_or_create_by_name_and_size("apples", "large")
end
it "passes context to the decorator" do
Product.stub(:find_by_name_and_size)
allow(Product).to receive(:find_by_name_and_size)
context = {some: "context"}
decorator = ProductDecorator.find_by_name_and_size("apples", "large", context: context)
@ -73,13 +73,13 @@ module Draper
describe ".find_all_by_" do
it "proxies to the model class" do
Product.should_receive(:find_all_by_name_and_size).with("apples", "large").and_return([])
expect(Product).to receive(:find_all_by_name_and_size).with("apples", "large").and_return([])
ProductDecorator.find_all_by_name_and_size("apples", "large")
end
it "decorates the result" do
found = [Product.new, Product.new]
Product.stub(:find_all_by_name).and_return(found)
allow(Product).to receive(:find_all_by_name).and_return(found)
decorator = ProductDecorator.find_all_by_name("apples")
expect(decorator).to be_a Draper::CollectionDecorator
@ -88,7 +88,7 @@ module Draper
end
it "passes context to the decorator" do
Product.stub(:find_all_by_name)
allow(Product).to receive(:find_all_by_name)
context = {some: "context"}
decorator = ProductDecorator.find_all_by_name("apples", context: context)
@ -99,7 +99,7 @@ module Draper
describe ".all" do
it "returns a decorated collection" do
found = [Product.new, Product.new]
Product.stub all: found
allow(Product).to receive_messages all: found
decorator = ProductDecorator.all
expect(decorator).to be_a Draper::CollectionDecorator
@ -108,7 +108,7 @@ module Draper
end
it "passes context to the decorator" do
Product.stub(:all)
allow(Product).to receive(:all)
context = {some: "context"}
decorator = ProductDecorator.all(context: context)
@ -118,20 +118,20 @@ module Draper
describe ".first" do
it "proxies to the model class" do
Product.should_receive(:first)
expect(Product).to receive(:first)
ProductDecorator.first
end
it "decorates the result" do
first = Product.new
Product.stub(:first).and_return(first)
allow(Product).to receive(:first).and_return(first)
decorator = ProductDecorator.first
expect(decorator).to be_a ProductDecorator
expect(decorator.object).to be first
end
it "passes context to the decorator" do
Product.stub(:first)
allow(Product).to receive(:first)
context = {some: "context"}
decorator = ProductDecorator.first(context: context)
@ -141,20 +141,20 @@ module Draper
describe ".last" do
it "proxies to the model class" do
Product.should_receive(:last)
expect(Product).to receive(:last)
ProductDecorator.last
end
it "decorates the result" do
last = Product.new
Product.stub(:last).and_return(last)
allow(Product).to receive(:last).and_return(last)
decorator = ProductDecorator.last
expect(decorator).to be_a ProductDecorator
expect(decorator.object).to be last
end
it "passes context to the decorator" do
Product.stub(:last)
allow(Product).to receive(:last)
context = {some: "context"}
decorator = ProductDecorator.last(context: context)

4
spec/draper/helper_proxy_spec.rb
View file

@ -18,7 +18,7 @@ module Draper
view_context = double
helper_proxy = HelperProxy.new(view_context)
view_context.stub(:foo) { |arg| arg }
allow(view_context).to receive(:foo) { |arg| arg }
expect(helper_proxy.foo(:passed)).to be :passed
end
@ -26,7 +26,7 @@ module Draper
view_context = double
helper_proxy = HelperProxy.new(view_context)
view_context.stub(:foo) { |&block| block.call }
allow(view_context).to receive(:foo) { |&block| block.call }
expect(helper_proxy.foo{:yielded}).to be :yielded
end

4
spec/draper/lazy_helpers_spec.rb
View file

@ -8,12 +8,12 @@ module Draper
end
it "proxies methods to #helpers" do
decorator.helpers.stub(:foo) { |arg| arg }
allow(decorator.helpers).to receive(:foo) { |arg| arg }
expect(decorator.foo(:passed)).to be :passed
end
it "passes blocks" do
decorator.helpers.stub(:foo) { |&block| block.call }
allow(decorator.helpers).to receive(:foo) { |&block| block.call }
expect(decorator.foo{:yielded}).to be :yielded
end
end

8
spec/draper/view_context/build_strategy_spec.rb
View file

@ -14,7 +14,7 @@ module Draper
context "when a current controller is set" do
it "returns the controller's view context" do
view_context = fake_view_context
ViewContext.stub controller: fake_controller(view_context)
allow(ViewContext).to receive_messages controller: fake_controller(view_context)
strategy = ViewContext::BuildStrategy::Full.new
expect(strategy.call).to be view_context
@ -33,7 +33,7 @@ module Draper
it "adds a request if one is not defined" do
controller = Class.new(ActionController::Base).new
ViewContext.stub controller: controller
allow(ViewContext).to receive_messages controller: controller
strategy = ViewContext::BuildStrategy::Full.new
expect(controller.request).to be_nil
@ -47,7 +47,7 @@ module Draper
end
it "adds methods to the view context from the constructor block" do
ViewContext.stub controller: fake_controller
allow(ViewContext).to receive(:controller).and_return(fake_controller)
strategy = ViewContext::BuildStrategy::Full.new do
def a_helper_method; end
end
@ -57,7 +57,7 @@ module Draper
it "includes modules into the view context from the constructor block" do
view_context = Object.new
ViewContext.stub controller: fake_controller(view_context)
allow(ViewContext).to receive(:controller).and_return(fake_controller(view_context))
helpers = Module.new do
def a_helper_method; end
end

42
spec/draper/view_context_spec.rb
View file

@ -7,7 +7,7 @@ module Draper
let(:controller) { Class.new(base) { include ViewContext } }
it "saves the superclass's view context" do
ViewContext.should_receive(:current=).with(:controller_view_context)
expect(ViewContext).to receive(:current=).with(:controller_view_context)
controller.new.view_context
end
@ -18,7 +18,7 @@ module Draper
describe ".controller" do
it "returns the stored controller from RequestStore" do
RequestStore.stub store: {current_controller: :stored_controller}
allow(RequestStore).to receive_messages store: {current_controller: :stored_controller}
expect(ViewContext.controller).to be :stored_controller
end
@ -27,7 +27,7 @@ module Draper
describe ".controller=" do
it "stores a controller in RequestStore" do
store = {}
RequestStore.stub store: store
allow(RequestStore).to receive_messages store: store
ViewContext.controller = :stored_controller
expect(store[:current_controller]).to be :stored_controller
@ -36,25 +36,25 @@ module Draper
describe ".current" do
it "returns the stored view context from RequestStore" do
RequestStore.stub store: {current_view_context: :stored_view_context}
allow(RequestStore).to receive_messages store: {current_view_context: :stored_view_context}
expect(ViewContext.current).to be :stored_view_context
end
context "when no view context is stored" do
it "builds a view context" do
RequestStore.stub store: {}
ViewContext.stub build_strategy: ->{ :new_view_context }
HelperProxy.stub(:new).with(:new_view_context).and_return(:new_helper_proxy)
allow(RequestStore).to receive_messages store: {}
allow(ViewContext).to receive_messages build_strategy: ->{ :new_view_context }
allow(HelperProxy).to receive(:new).with(:new_view_context).and_return(:new_helper_proxy)
expect(ViewContext.current).to be :new_helper_proxy
end
it "stores the built view context" do
store = {}
RequestStore.stub store: store
ViewContext.stub build_strategy: ->{ :new_view_context }
HelperProxy.stub(:new).with(:new_view_context).and_return(:new_helper_proxy)
allow(RequestStore).to receive_messages store: store
allow(ViewContext).to receive_messages build_strategy: ->{ :new_view_context }
allow(HelperProxy).to receive(:new).with(:new_view_context).and_return(:new_helper_proxy)
ViewContext.current
expect(store[:current_view_context]).to be :new_helper_proxy
@ -65,8 +65,8 @@ module Draper
describe ".current=" do
it "stores a helper proxy for the view context in RequestStore" do
store = {}
RequestStore.stub store: store
HelperProxy.stub(:new).with(:stored_view_context).and_return(:stored_helper_proxy)
allow(RequestStore).to receive_messages store: store
allow(HelperProxy).to receive(:new).with(:stored_view_context).and_return(:stored_helper_proxy)
ViewContext.current = :stored_view_context
expect(store[:current_view_context]).to be :stored_helper_proxy
@ -76,7 +76,7 @@ module Draper
describe ".clear!" do
it "clears the stored controller and view controller" do
store = {current_controller: :stored_controller, current_view_context: :stored_view_context}
RequestStore.stub store: store
allow(RequestStore).to receive_messages store: store
ViewContext.clear!
expect(store).not_to have_key :current_controller
@ -86,7 +86,7 @@ module Draper
describe ".build" do
it "returns a new view context using the build strategy" do
ViewContext.stub build_strategy: ->{ :new_view_context }
allow(ViewContext).to receive_messages build_strategy: ->{ :new_view_context }
expect(ViewContext.build).to be :new_view_context
end
@ -94,17 +94,17 @@ module Draper
describe ".build!" do
it "returns a helper proxy for the new view context" do
ViewContext.stub build_strategy: ->{ :new_view_context }
HelperProxy.stub(:new).with(:new_view_context).and_return(:new_helper_proxy)
allow(ViewContext).to receive_messages build_strategy: ->{ :new_view_context }
allow(HelperProxy).to receive(:new).with(:new_view_context).and_return(:new_helper_proxy)
expect(ViewContext.build!).to be :new_helper_proxy
end
it "stores the helper proxy" do
store = {}
RequestStore.stub store: store
ViewContext.stub build_strategy: ->{ :new_view_context }
HelperProxy.stub(:new).with(:new_view_context).and_return(:new_helper_proxy)
allow(RequestStore).to receive_messages store: store
allow(ViewContext).to receive_messages build_strategy: ->{ :new_view_context }
allow(HelperProxy).to receive(:new).with(:new_view_context).and_return(:new_helper_proxy)
ViewContext.build!
expect(store[:current_view_context]).to be :new_helper_proxy
@ -131,7 +131,7 @@ module Draper
end
it "passes a block to the strategy" do
ViewContext::BuildStrategy::Fast.stub(:new) { |&block| block.call }
allow(ViewContext::BuildStrategy::Fast).to receive(:new) { |&block| block.call }
expect(ViewContext.test_strategy(:fast){:passed}).to be :passed
end
@ -144,7 +144,7 @@ module Draper
end
it "passes a block to the strategy" do
ViewContext::BuildStrategy::Full.stub(:new) { |&block| block.call }
allow(ViewContext::BuildStrategy::Full).to receive(:new) { |&block| block.call }
expect(ViewContext.test_strategy(:full){:passed}).to be :passed
end

4
spec/generators/controller/controller_generator_spec.rb
View file

@ -16,7 +16,7 @@ describe Rails::Generators::ControllerGenerator do
describe "naming" do
before { run_generator %w(YourModels) }
it { should contain "class YourModelDecorator" }
it { is_expected.to contain "class YourModelDecorator" }
end
end
end
end

18
spec/generators/decorator/decorator_generator_spec.rb
View file

@ -15,27 +15,27 @@ describe Rails::Generators::DecoratorGenerator do
describe "naming" do
before { run_generator %w(YourModel) }
it { should contain "class YourModelDecorator" }
it { is_expected.to contain "class YourModelDecorator" }
end
describe "namespacing" do
subject { file("app/decorators/namespace/your_model_decorator.rb") }
before { run_generator %w(Namespace::YourModel) }
it { should contain "class Namespace::YourModelDecorator" }
it { is_expected.to contain "class Namespace::YourModelDecorator" }
end
describe "inheritance" do
context "by default" do
before { run_generator %w(YourModel) }
it { should contain "class YourModelDecorator < Draper::Decorator" }
it { is_expected.to contain "class YourModelDecorator < Draper::Decorator" }
end
context "with the --parent option" do
before { run_generator %w(YourModel --parent=FooDecorator) }
it { should contain "class YourModelDecorator < FooDecorator" }
it { is_expected.to contain "class YourModelDecorator < FooDecorator" }
end
context "with an ApplicationDecorator" do
@ -47,7 +47,7 @@ describe Rails::Generators::DecoratorGenerator do
before { run_generator %w(YourModel) }
it { should contain "class YourModelDecorator < ApplicationDecorator" }
it { is_expected.to contain "class YourModelDecorator < ApplicationDecorator" }
end
end
end
@ -59,14 +59,14 @@ describe Rails::Generators::DecoratorGenerator do
describe "naming" do
before { run_generator %w(YourModel -t=rspec) }
it { should contain "describe YourModelDecorator" }
it { is_expected.to contain "describe YourModelDecorator" }
end
describe "namespacing" do
subject { file("spec/decorators/namespace/your_model_decorator_spec.rb") }
before { run_generator %w(Namespace::YourModel -t=rspec) }
it { should contain "describe Namespace::YourModelDecorator" }
it { is_expected.to contain "describe Namespace::YourModelDecorator" }
end
end
end
@ -78,14 +78,14 @@ describe Rails::Generators::DecoratorGenerator do
describe "naming" do
before { run_generator %w(YourModel -t=test_unit) }
it { should contain "class YourModelDecoratorTest < Draper::TestCase" }
it { is_expected.to contain "class YourModelDecoratorTest < Draper::TestCase" }
end
describe "namespacing" do
subject { file("test/decorators/namespace/your_model_decorator_test.rb") }
before { run_generator %w(Namespace::YourModel -t=test_unit) }
it { should contain "class Namespace::YourModelDecoratorTest < Draper::TestCase" }
it { is_expected.to contain "class Namespace::YourModelDecoratorTest < Draper::TestCase" }
end
end
end

16
spec/support/shared_examples/view_helpers.rb
View file

@ -1,38 +1,38 @@
shared_examples_for "view helpers" do |subject|
describe "#helpers" do
it "returns the current view context" do
Draper::ViewContext.stub current: :current_view_context
allow(Draper::ViewContext).to receive_messages current: :current_view_context
expect(subject.helpers).to be :current_view_context
end
it "is aliased to #h" do
Draper::ViewContext.stub current: :current_view_context
allow(Draper::ViewContext).to receive_messages current: :current_view_context
expect(subject.h).to be :current_view_context
end
end
describe "#localize" do
it "delegates to #helpers" do
subject.stub helpers: double
subject.helpers.should_receive(:localize).with(:an_object, some: "parameter")
allow(subject).to receive(:helpers).and_return(double)
expect(subject.helpers).to receive(:localize).with(:an_object, some: "parameter")
subject.localize(:an_object, some: "parameter")
end
it "is aliased to #l" do
subject.stub helpers: double
subject.helpers.should_receive(:localize).with(:an_object, some: "parameter")
allow(subject).to receive_messages helpers: double
expect(subject.helpers).to receive(:localize).with(:an_object, some: "parameter")
subject.l(:an_object, some: "parameter")
end
end
describe ".helpers" do
it "returns the current view context" do
Draper::ViewContext.stub current: :current_view_context
allow(Draper::ViewContext).to receive_messages current: :current_view_context
expect(subject.class.helpers).to be :current_view_context
end
it "is aliased to .h" do
Draper::ViewContext.stub current: :current_view_context
allow(Draper::ViewContext).to receive(:current).and_return(:current_view_context)
expect(subject.class.h).to be :current_view_context
end
end