alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/libraries/resource_spec.rb

@@ -54,23 +54,23 @@ module Alchemy
 
     before :each do
       # stubbing an ActiveRecord::ModelSchema...
-      Party.stub(:columns).and_return columns
+      allow(Party).to receive(:columns).and_return columns
     end
 
     describe "#initialize" do
       it "sets the standard database attributes (rails defaults) to be skipped" do
         resource = Resource.new("admin/parties")
-        resource.skipped_attributes.should == %w(id updated_at created_at creator_id updater_id)
+        expect(resource.skipped_attributes).to eq(%w(id updated_at created_at creator_id updater_id))
       end
 
       it "sets an instance variable that holds the controller path" do
         resource = Resource.new("admin/parties")
-        resource.instance_variable_get(:@controller_path).should == "admin/parties"
+        expect(resource.instance_variable_get(:@controller_path)).to eq("admin/parties")
       end
 
       context "when initialized with a module definition" do
         it "sets an instance variable that holds the module definition" do
-          resource.instance_variable_get(:@module_definition).should == module_definition
+          expect(resource.instance_variable_get(:@module_definition)).to eq(module_definition)
         end
       end
 
@@ -78,14 +78,14 @@ module Alchemy
         it "sets @model to custom model" do
           CustomParty = Class.new
           resource = Resource.new("admin/parties", nil, CustomParty)
-          resource.instance_variable_get(:@model).should == CustomParty
+          expect(resource.instance_variable_get(:@model)).to eq(CustomParty)
         end
       end
 
       context "when initialized without custom model" do
         it "guesses the model by the controller_path" do
           resource = Resource.new("admin/parties", nil, nil)
-          resource.instance_variable_get(:@model).should == Party
+          expect(resource.instance_variable_get(:@model)).to eq(Party)
         end
       end
 
@@ -100,7 +100,7 @@ module Alchemy
 
         context ", but not an ActiveRecord association" do
           before do
-            Party.stub(:respond_to?).and_return do |arg|
+            allow(Party).to receive(:respond_to?) do |arg|
               case arg
               when :reflect_on_all_associations
                 then false
@@ -128,84 +128,84 @@ module Alchemy
     describe "#resource_array" do
       it "splits the controller_path and returns it as array." do
         resource = Resource.new("namespace1/namespace2/parties")
-        resource.resource_array.should eql(%w(namespace1 namespace2 parties))
+        expect(resource.resource_array).to eql(%w(namespace1 namespace2 parties))
       end
 
       it "deletes 'admin' if found hence our model isn't in the admin-namespace by convention" do
-        resource.resource_array.should eql(%w(parties))
+        expect(resource.resource_array).to eql(%w(parties))
       end
     end
 
     describe "#model" do
       it "returns the @model instance variable" do
-        resource.model.should == resource.instance_variable_get(:@model)
+        expect(resource.model).to eq(resource.instance_variable_get(:@model))
       end
     end
 
     describe "#resources_name" do
       it "returns plural name (like parties for model Party)" do
-        resource.resources_name.should == "parties"
+        expect(resource.resources_name).to eq("parties")
       end
     end
 
     describe "#resource_name" do
       it "returns the resources name as singular" do
-        resource.resource_name.should == "party"
+        expect(resource.resource_name).to eq("party")
       end
     end
 
     describe "#namespaced_resource_name" do
       it "returns resource_name with namespace (namespace_party for Namespace::Party), i.e. for use in forms" do
         namespaced_resource = Resource.new("admin/namespace/parties")
-        namespaced_resource.namespaced_resource_name.should == 'namespace_party'
+        expect(namespaced_resource.namespaced_resource_name).to eq('namespace_party')
       end
 
       it "equals resource_name if resource not namespaced" do
         namespaced_resource = Resource.new("admin/parties")
-        namespaced_resource.namespaced_resource_name.should == 'party'
+        expect(namespaced_resource.namespaced_resource_name).to eq('party')
       end
 
       it "doesn't include the engine's name" do
         namespaced_resource = Resource.new("admin/party_engine/namespace/parties", module_definition)
-        namespaced_resource.namespaced_resource_name.should == 'namespace_party'
+        expect(namespaced_resource.namespaced_resource_name).to eq('namespace_party')
       end
     end
 
     describe "#engine_name" do
       it "should return the engine name of the module" do
         resource = Resource.new("admin/party_engine/namespace/parties", module_definition)
-        resource.engine_name.should == "party_engine"
+        expect(resource.engine_name).to eq("party_engine")
       end
     end
 
     describe "#namespace_for_scope" do
       it "returns a scope for use in url_for based path helpers" do
-        resource.namespace_for_scope.should == %w(admin)
+        expect(resource.namespace_for_scope).to eq(%w(admin))
       end
     end
 
     describe "#attributes" do
       it "parses and returns the resource model's attributes from ActiveRecord::ModelSchema" do
-        resource.attributes.should == [
+        expect(resource.attributes).to eq([
           {:name => "name", :type => :string},
           {:name => "hidden_value", :type => :string},
           {:name => "description", :type => :string},
           {:name => "starts_at", :type => :datetime},
           {:name => "location_id", :type => :integer},
           {:name => "organizer_id", :type => :integer},
-        ]
+        ])
       end
 
       it "skips attributes returned by skipped_alchemy_resource_attributes" do
         # attr_accessor, hence skipped_alchemy_resource_attributes= works
         resource.skipped_attributes = %w(hidden_value)
-        resource.attributes.should include({:name => "id", :type => :integer})
-        resource.attributes.should_not include({:name => "hidden_value", :type => :string})
+        expect(resource.attributes).to include({:name => "id", :type => :integer})
+        expect(resource.attributes).not_to include({:name => "hidden_value", :type => :string})
       end
 
       context "when resource_relations are not defined" do
         it "includes the attribute" do
-          resource.attributes.detect { |a| a[:name] == "location_id" }.should == {:name => "location_id", :type => :integer}
+          expect(resource.attributes.detect { |a| a[:name] == "location_id" }).to eq({:name => "location_id", :type => :integer})
         end
       end
     end
@@ -221,8 +221,8 @@ module Alchemy
 
       describe '#attributes' do
         it "does not return the attributes returned by that method" do
-          resource.attributes.detect { |a| a[:name] == 'hidden_name' }.should be_nil
-          resource.attributes.detect { |a| a[:name] == 'name' }.should_not be_nil
+          expect(resource.attributes.detect { |a| a[:name] == 'hidden_name' }).to be_nil
+          expect(resource.attributes.detect { |a| a[:name] == 'name' }).not_to be_nil
         end
       end
 
@@ -248,11 +248,11 @@ module Alchemy
       before { resource.skipped_attributes = [] }
 
       it "returns all attributes of type string" do
-        should == [
+        is_expected.to eq([
           {:name => "name", :type => :string},
           {:name => "hidden_value", :type => :string},
           {:name => "description", :type => :string}
-        ]
+        ])
       end
 
       context "with an array attribute" do
@@ -264,7 +264,7 @@ module Alchemy
         end
 
         it "does not include this column" do
-          should == [{name: "name", type: :string}]
+          is_expected.to eq([{name: "name", type: :string}])
         end
       end
     end
@@ -285,34 +285,34 @@ module Alchemy
       describe '#resource_relations' do
         it "should contain model_association from ActiveRecord::Reflections" do
           relation = resource.resource_relations[:location_id]
-          relation.keys.should include(:model_association)
-          relation[:model_association].class.should be(ActiveRecord::Reflection::AssociationReflection)
+          expect(relation.keys).to include(:model_association)
+          expect(relation[:model_association].class).to be(ActiveRecord::Reflection::AssociationReflection)
         end
 
         it "adds '_id' to relation key" do
-          resource.resource_relations[:location_id].should_not be_nil
+          expect(resource.resource_relations[:location_id]).not_to be_nil
         end
 
         it "stores the relation name" do
           relation = resource.resource_relations[:location_id]
-          relation.keys.should include(:name)
-          relation[:name].should == 'location'
+          expect(relation.keys).to include(:name)
+          expect(relation[:name]).to eq('location')
         end
       end
 
       describe '#model_associations' do
         it "skip default alchemy model associations" do
-          resource.model_associations.collect(&:name).should_not include(*resource.class.const_get(:DEFAULT_SKIPPED_ASSOCIATIONS).map(&:to_sym))
+          expect(resource.model_associations.collect(&:name)).not_to include(*resource.class.const_get(:DEFAULT_SKIPPED_ASSOCIATIONS).map(&:to_sym))
         end
       end
 
       describe '#attributes' do
         it "contains the attribute of the related model" do
-          resource.attributes.detect { |a| a[:name] == 'location_id' }.keys.should include(:relation)
+          expect(resource.attributes.detect { |a| a[:name] == 'location_id' }.keys).to include(:relation)
         end
 
         it "contains the related model's column type as type" do
-          resource.attributes.detect { |a| a[:name] == "location_id" }[:type].should == :string
+          expect(resource.attributes.detect { |a| a[:name] == "location_id" }[:type]).to eq(:string)
         end
       end
 
@@ -327,13 +327,13 @@ module Alchemy
 
     describe "#engine_name" do
       it "should return the engine name of the module" do
-        resource.engine_name.should == "party_engine"
+        expect(resource.engine_name).to eq("party_engine")
       end
     end
 
     describe "#in_engine?" do
       it "should return true if the module is shipped within an engine" do
-        resource.in_engine?.should == true
+        expect(resource.in_engine?).to eq(true)
       end
     end
 

data/spec/libraries/resources_helper_spec.rb

@@ -31,7 +31,7 @@ describe Alchemy::ResourcesHelper do
   let(:resource_item) { double('resource-item') }
 
   before {
-    controller.stub(:main_app).and_return 'main_app_proxy'
+    allow(controller).to receive(:main_app).and_return 'main_app_proxy'
     controller.instance_variable_set('@my_resource', resource_item)
     controller.instance_variable_set('@my_resources', [resource_item])
   }
@@ -39,48 +39,48 @@ describe Alchemy::ResourcesHelper do
   describe "path-helpers" do
     describe "#resource_url_proxy" do
       it "returns the current proxy for url-helper-methods" do
-        controller.resource_url_proxy.should == 'main_app_proxy'
+        expect(controller.resource_url_proxy).to eq('main_app_proxy')
       end
 
       context "when resource is in engine" do
         let(:controller_for_engine) { ResourcesControllerForEngine.new }
-        before { controller_for_engine.stub('my_engine').and_return('my_engine_proxy') }
+        before { allow(controller_for_engine).to receive('my_engine').and_return('my_engine_proxy') }
 
         it "returns the engine's proxy" do
-          controller_for_engine.resource_url_proxy.should == 'my_engine_proxy'
+          expect(controller_for_engine.resource_url_proxy).to eq('my_engine_proxy')
         end
       end
     end
 
     describe "#resource_scope" do
       it "returns an array containing a proxy and namespaces for url_for-based helper-methods" do
-        controller.resource_scope.should == %W[main_app_proxy admin]
+        expect(controller.resource_scope).to eq(%W[main_app_proxy admin])
       end
     end
 
     describe "#resource_path" do
       it "invokes polymorphic-path with correct scope and object" do
         my_resource_item = double
-        controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
+        expect(controller).to receive(:polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
         controller.resource_path(my_resource_item)
       end
 
       it "uses resource_name when no object is given" do
-        controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", "my_resource"], {})
+        expect(controller).to receive(:polymorphic_path).with(["main_app_proxy", "admin", "my_resource"], {})
         controller.resource_path
       end
     end
 
     describe "#resources_path" do
       it "invokes polymorphic-path with correct scope and resources_name" do
-        controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", "my_resources"], {})
+        expect(controller).to receive(:polymorphic_path).with(["main_app_proxy", "admin", "my_resources"], {})
         controller.resources_path
       end
     end
 
     describe "#new_resource_path" do
       it "invokes new_polymorphic_path with correct scope and resource_name" do
-        controller.should_receive(:new_polymorphic_path).with(["main_app_proxy", "admin", "my_resource"], {})
+        expect(controller).to receive(:new_polymorphic_path).with(["main_app_proxy", "admin", "my_resource"], {})
         controller.new_resource_path
       end
     end
@@ -88,7 +88,7 @@ describe Alchemy::ResourcesHelper do
     describe "#edit_resource_path" do
       it "invokes edit_polymorphic_path with correct scope and resource_name" do
         my_resource_item = double
-        controller.should_receive(:edit_polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
+        expect(controller).to receive(:edit_polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
         controller.edit_resource_path(my_resource_item)
       end
     end
@@ -96,27 +96,27 @@ describe Alchemy::ResourcesHelper do
 
   describe "#resource_instance_variable" do
     it "returns the resource_item" do
-      controller.resource_instance_variable.should == resource_item
+      expect(controller.resource_instance_variable).to eq(resource_item)
     end
   end
 
   describe "#resources_instance_variable" do
     it "returns a collection of resource_items" do
-      controller.resources_instance_variable.should == [resource_item]
+      expect(controller.resources_instance_variable).to eq([resource_item])
     end
   end
 
   describe "#resource_window_size" do
     it "returns overlay size string depending on resource attributes length" do
-      controller.stub_chain(:resource_handler, :attributes, :length).and_return(4)
-      controller.resource_window_size.should == "420x260"
+      allow(controller).to receive(:resource_handler).and_return double(attributes: double(length: 4))
+      expect(controller.resource_window_size).to eq("420x260")
     end
   end
 
   describe "#render_attribute" do
     it "should return the value from resource attribute" do
-      resource_item.stub(:name).and_return('my-name')
-      controller.render_attribute(resource_item, {name: 'name'}).should == 'my-name'
+      allow(resource_item).to receive(:name).and_return('my-name')
+      expect(controller.render_attribute(resource_item, {name: 'name'})).to eq('my-name')
     end
 
     context "resource having a relation" do
@@ -130,15 +130,15 @@ describe Alchemy::ResourcesHelper do
       }
 
       it "should return the value from the related object attribute" do
-        resource_item.stub(:name).and_return('my-name')
-        controller.render_attribute(resource_item, {name: 'name', relation: relation}).should == 'Title of related object'
+        allow(resource_item).to receive(:name).and_return('my-name')
+        expect(controller.render_attribute(resource_item, {name: 'name', relation: relation})).to eq('Title of related object')
       end
     end
   end
 
   describe "#resource_name" do
     it "returns resource_handler.resource_name" do
-      controller.resource_name.should == "my_resource"
+      expect(controller.resource_name).to eq("my_resource")
     end
   end
 end

data/spec/libraries/shell_spec.rb

@@ -10,11 +10,11 @@ module Alchemy
 
   describe Shell do
 
-    before { MyToDoList.stub(:puts) }
+    before { allow(MyToDoList).to receive(:puts) }
 
     describe '.todo' do
       it "should add given string as a todo by delegating to .add_todo" do
-        MyToDoList.should_receive(:add_todo).with(["", "new todo"])
+        expect(MyToDoList).to receive(:add_todo).with(["", "new todo"])
         MyToDoList.todo("new todo")
       end
     end
@@ -36,27 +36,27 @@ module Alchemy
     describe '.display_todos' do
       context 'if there are todos in the list' do
         before do
-          MyToDoList.stub(:todos).and_return(['My first todo', 'My second todo'])
+          allow(MyToDoList).to receive(:todos).and_return(['My first todo', 'My second todo'])
         end
 
         it "should log them" do
-          MyToDoList.should_receive(:log).at_least(1).times
+          expect(MyToDoList).to receive(:log).at_least(1).times
           MyToDoList.display_todos
         end
 
         it "should iterate through the todos with an index" do
-          MyToDoList.todos.should_receive(:each_with_index)
+          expect(MyToDoList.todos).to receive(:each_with_index)
           MyToDoList.display_todos
         end
       end
 
       context 'if there are todos in the list' do
         before do
-          MyToDoList.stub(:todos).and_return([])
+          allow(MyToDoList).to receive(:todos).and_return([])
         end
 
         it "should not log anything" do
-          MyToDoList.should_not_receive(:log)
+          expect(MyToDoList).not_to receive(:log)
           MyToDoList.display_todos
         end
       end
@@ -65,31 +65,31 @@ module Alchemy
     describe '.log' do
       context 'if the message type is "skip"' do
         it "the output color should be yellow and cleared again" do
-          MyToDoList.should_receive(:color).with(:yellow)
-          MyToDoList.should_receive(:color).with(:clear)
+          expect(MyToDoList).to receive(:color).with(:yellow)
+          expect(MyToDoList).to receive(:color).with(:clear)
           MyToDoList.log('in yellow, please', :skip)
         end
       end
 
       context 'if the message type is "error"' do
         it "the output color should be yellow and cleared again" do
-          MyToDoList.should_receive(:color).with(:red)
-          MyToDoList.should_receive(:color).with(:clear)
+          expect(MyToDoList).to receive(:color).with(:red)
+          expect(MyToDoList).to receive(:color).with(:clear)
           MyToDoList.log('in red, please', :error)
         end
       end
 
       context 'if the message type is "message"' do
         it "the output color should just be cleared" do
-          MyToDoList.should_receive(:color).with(:clear)
+          expect(MyToDoList).to receive(:color).with(:clear)
           MyToDoList.log('cleared, please', :message)
         end
       end
 
       context 'if no message type is given' do
         it "the output color should be green" do
-          MyToDoList.should_receive(:color).with(:green)
-          MyToDoList.should_receive(:color).with(:clear)
+          expect(MyToDoList).to receive(:color).with(:green)
+          expect(MyToDoList).to receive(:color).with(:clear)
           MyToDoList.log('in green, please')
         end
       end
@@ -99,18 +99,18 @@ module Alchemy
 
       context 'if given name is a constant of Thor::Shell::Color' do
         before do
-          Thor::Shell::Color.stub(:const_defined?).and_return(true)
+          allow(Thor::Shell::Color).to receive(:const_defined?).and_return(true)
         end
 
         it "should call the constant" do
-          String.any_instance.should_receive(:constantize).and_return('')
+          expect_any_instance_of(String).to receive(:constantize).and_return('')
           MyToDoList.send(:color, :red)
         end
       end
 
       context 'if given name is not a defined constant of Thor::Shell::Color' do
         before do
-          Thor::Shell::Color.stub(:const_defined?).and_return(false)
+          allow(Thor::Shell::Color).to receive(:const_defined?).and_return(false)
         end
 
         it "should return en empty string" do