simple-navigation 3.11.0 → 3.12.0

data/spec/lib/simple_navigation/core/items_provider_spec.rb

@@ -1,60 +1,46 @@
 require 'spec_helper'
 
-describe SimpleNavigation::ItemsProvider do
+module SimpleNavigation
+  describe ItemsProvider do
+    let(:items_provider) { ItemsProvider.new(provider) }
 
-  before(:each) do
-    @provider = stub(:provider)
-    @items_provider = SimpleNavigation::ItemsProvider.new(@provider)
-  end
+    describe '#items' do
+      let(:items) { double(:items) }
 
-  describe 'initialize' do
-    it "should set the provider" do
-      @items_provider.provider.should == @provider
-    end
-  end
+      context 'when provider is a symbol' do
+        let(:context) { double(:context, provider_method: items) }
+        let(:provider) { :provider_method }
 
-  describe 'items' do
-    before(:each) do
-      @items = stub(:items)
-    end
-    context 'provider is symbol' do
-      before(:each) do
-        @items_provider.instance_variable_set(:@provider, :provider_method)
-        @context = stub(:context, :provider_method => @items)
-        SimpleNavigation.stub!(:context_for_eval => @context)
-      end
-      it "should call the method specified by symbol on the context" do
-        @context.should_receive(:provider_method)
-        @items_provider.items
-      end
-      it "should return the items returned by the helper method" do
-        @items_provider.items.should == @items
-      end
-    end
-    context 'provider responds to items' do
-      before(:each) do
-        @provider.stub!(:items => @items)
-      end
-      it "should get the items from the items_provider" do
-        @provider.should_receive(:items)
-        @items_provider.items
+        before { SimpleNavigation.stub(context_for_eval: context) }
+
+        it 'retrieves the items from the evaluation context' do
+          expect(items_provider.items).to eq items
+        end
       end
-      it "should return the items of the provider" do
-        @items_provider.items.should == @items
+
+      context 'when provider responds to :items' do
+        let(:provider) { double(:provider, items: items) }
+
+        it 'retrieves the items from the provider object' do
+          expect(items_provider.items).to eq items
+        end
       end
-    end
-    context 'provider is a collection' do
-      before(:each) do
-        @items_collection = []
-        @items_provider.instance_variable_set(:@provider, @items_collection)
+
+      context 'provider is a collection' do
+        let(:provider) { [] }
+
+        it 'retrieves the items by returning the provider' do
+          expect(items_provider.items).to eq provider
+        end
       end
-      it "should return the collection itsself" do
-        @items_provider.items.should == @items_collection
+
+      context 'when provider is something else' do
+        let(:provider) { double(:provider) }
+
+        it 'raises an exception' do
+          expect{ items_provider.items }.to raise_error
+        end
       end
     end
-    context 'neither symbol nor items_provider.items nor collection' do
-      it {lambda {@items_provider.items}.should raise_error}
-    end
   end
-
-end
+end

data/spec/lib/simple_navigation/rails_controller_methods_spec.rb

@@ -1,249 +1,270 @@
 require 'spec_helper'
+require 'simple_navigation/rails_controller_methods'
 
-describe 'explicit navigation in rails' do
-  require 'simple_navigation/rails_controller_methods'
+class TestController
+  include SimpleNavigation::ControllerMethods
 
-  it 'should have enhanced the ActionController after loading the extensions' do
-    ActionController::Base.instance_methods.map {|m| m.to_s}.should include('current_navigation')
+  def self.helper_method(*args)
+    @helper_methods = args
   end
 
-  describe SimpleNavigation::ControllerMethods do
+  def self.before_filter(*args)
+    @before_filters = args
+  end
+end
 
-    def stub_loading_config
-      SimpleNavigation::Configuration.stub!(:load)
+module SimpleNavigation
+  describe 'Explicit navigation in rails' do
+    it 'enhances ActionController after loading the extensions' do
+      methods = ActionController::Base.instance_methods.map(&:to_s)
+      expect(methods).to include 'current_navigation'
     end
+  end
 
-    before(:each) do
-      stub_loading_config
-      class TestController
-        class << self
-          def helper_method(*args)
-            @helper_methods = args
-          end
-          def before_filter(*args)
-            @before_filters = args
-          end
-        end
-      end
-      TestController.send(:include, SimpleNavigation::ControllerMethods)
-      @controller = TestController.new
-    end
+  describe ControllerMethods do
+    let(:controller) { TestController.new }
+
+    before { SimpleNavigation::Configuration.stub(:load) }
 
-    describe 'when being included' do
-      it "should extend the ClassMethods" do
-        @controller.class.should respond_to(:navigation)
+    describe 'when the module is included' do
+      it 'extends the ClassMethods module' do
+        expect(controller.class).to respond_to(:navigation)
       end
-      it "should include the InstanceMethods" do
-        @controller.should respond_to(:current_navigation)
+
+      it "includes the InstanceMethods module" do
+        expect(controller).to respond_to(:current_navigation)
       end
     end
+  end
 
-    describe 'class_methods' do
-
-      describe 'navigation' do
+  module ControllerMethods
+    describe ClassMethods do
+      let(:controller) { TestController.new }
 
-        def call_navigation(key1, key2=nil)
-          @controller.class_eval do
-            navigation key1, key2
+      describe '#navigation' do
+        context 'when the navigation method is not called' do
+          it "doesn't have any instance method called 'sn_set_navigation'" do
+            has_method = controller.respond_to?(:sn_set_navigation, true)
+            expect(has_method).to be_false
           end
         end
 
-        it "should not have an instance-method 'sn_set_navigation' if navigation-method has not been called" do
-          @controller.respond_to?(:sn_set_navigation).should be_false
-        end
-        it 'should create an instance-method "sn_set_navigation" when being called' do
-          call_navigation(:key)
-          @controller.respond_to?(:sn_set_navigation, true).should be_true
-        end
-        it "the created method should not be public" do
-          call_navigation(:key)
-          @controller.public_methods.map(&:to_sym).should_not include(:sn_set_navigation)
-        end
-        it "the created method should be protected" do
-          call_navigation(:key)
-          @controller.protected_methods.map(&:to_sym).should include(:sn_set_navigation)
-        end
-        it 'the created method should call current_navigation with the specified keys' do
-          call_navigation(:primary, :secondary)
-          @controller.should_receive(:current_navigation).with(:primary, :secondary)
-          @controller.send(:sn_set_navigation)
+        context 'when the navigation method is called' do
+          before do
+            controller.class_eval { navigation(:primary, :secondary) }
+          end
+
+          it 'creates an instance method called "sn_set_navigation"' do
+            has_method = controller.respond_to?(:sn_set_navigation, true)
+            expect(has_method).to be_true
+          end
+
+          it 'does not create a public method' do
+            methods = controller.public_methods.map(&:to_s)
+            expect(methods).not_to include 'sn_set_navigation'
+          end
+
+          it 'creates a protected method' do
+            methods = controller.protected_methods.map(&:to_s)
+            expect(methods).to include 'sn_set_navigation'
+          end
+
+          it 'creates a method that calls current_navigation with the specified keys' do
+            expect(controller).to receive(:current_navigation)
+                                 .with(:primary, :secondary)
+            controller.send(:sn_set_navigation)
+          end
         end
       end
-
     end
 
-    describe 'instance_methods' do
+    describe InstanceMethods do
+      let(:controller) { TestController.new }
 
-      describe 'current_navigation' do
-        it "should set the sn_current_navigation_args as specified" do
-          @controller.current_navigation(:first)
-          @controller.instance_variable_get(:@sn_current_navigation_args).should == [:first]
-        end
-        it "should set the sn_current_navigation_args as specified" do
-          @controller.current_navigation(:first, :second)
-          @controller.instance_variable_get(:@sn_current_navigation_args).should == [:first, :second]
+      describe '#current_navigation' do
+        shared_examples 'setting the correct sn_current_navigation_args' do |args|
+          it 'sets the sn_current_navigation_args as specified' do
+            controller.current_navigation(*args)
+            args = controller.instance_variable_get(:@sn_current_navigation_args)
+            expect(args).to eq args
+          end
         end
-      end
 
+        it_behaves_like 'setting the correct sn_current_navigation_args', [:first]
+        it_behaves_like 'setting the correct sn_current_navigation_args', [:first, :second]
+      end
     end
-
   end
 
   describe 'SimpleNavigation module additions' do
+    let(:adapter) { double(:adapter, controller: controller) }
+    let(:controller) { double(:controller) }
+    let(:simple_navigation) { SimpleNavigation }
+
+    before { simple_navigation.stub(adapter: adapter) }
 
-    describe 'handle_explicit_navigation' do
+    describe '.handle_explicit_navigation' do
       def args(*args)
-        SimpleNavigation.stub!(:explicit_navigation_args => args.compact.empty? ? nil : args)
+        keys = args.compact.empty? ? nil : args
+        simple_navigation.stub(explicit_navigation_args: keys)
       end
 
-      before(:each) do
-        @controller = stub(:controller)
-        @adapter = stub(:adapter, :controller => @controller)
-        SimpleNavigation.stub!(:adapter => @adapter)
-      end
+      context 'when there is an explicit navigation set' do
+        context 'and it is a list of navigations' do
+          before { args :first, :second, :third }
 
-      context 'with explicit navigation set' do
-        context 'list of navigations' do
-          before(:each) do
-            args :first, :second, :third
-          end
-          it "should set the correct instance var in the controller" do
-            @controller.should_receive(:instance_variable_set).with(:@sn_current_navigation_3, :third)
-            SimpleNavigation.handle_explicit_navigation
+          it 'sets the correct instance var in the controller' do
+            expect(controller).to receive(:instance_variable_set)
+                                 .with(:@sn_current_navigation_3, :third)
+            simple_navigation.handle_explicit_navigation
           end
         end
-        context 'single navigation' do
-          context 'specified key is a valid navigation item' do
-            before(:each) do
-              @primary = stub(:primary, :level_for_item => 2)
-              SimpleNavigation.stub!(:primary_navigation => @primary)
+
+        context 'and it is a single navigation' do
+          context 'and the specified key is a valid navigation item' do
+            let(:primary) { double(:primary, level_for_item: 2) }
+
+            before do
+              simple_navigation.stub(primary_navigation: primary)
               args :key
             end
-            it "should set the correct instance var in the controller" do
-              @controller.should_receive(:instance_variable_set).with(:@sn_current_navigation_2, :key)
-              SimpleNavigation.handle_explicit_navigation
+
+            it 'sets the correct instance var in the controller' do
+              expect(controller).to receive(:instance_variable_set)
+                                    .with(:@sn_current_navigation_2, :key)
+              simple_navigation.handle_explicit_navigation
             end
           end
-          context 'specified key is an invalid navigation item' do
-            before(:each) do
-              @primary = stub(:primary, :level_for_item => nil)
-              SimpleNavigation.stub!(:primary_navigation => @primary)
+
+          context 'and the specified key is an invalid navigation item' do
+            let(:primary) { double(:primary, level_for_item: nil) }
+
+            before do
+              subject.stub(primary_navigation: primary)
               args :key
             end
-            it "should raise an ArgumentError" do
-              lambda {SimpleNavigation.handle_explicit_navigation}.should raise_error(ArgumentError)
+
+            it 'raises an exception' do
+              expect{ subject.handle_explicit_navigation }.to raise_error
             end
           end
         end
-        context 'hash with level' do
-          before(:each) do
-            args :level_2 => :key
-          end
-          it "should set the correct instance var in the controller" do
-            @controller.should_receive(:instance_variable_set).with(:@sn_current_navigation_2, :key)
-            SimpleNavigation.handle_explicit_navigation
+
+        context 'and the argument is a one-level hash' do
+          before { args level_2: :key }
+
+          it 'sets the correct instance var in the controller' do
+            expect(controller).to receive(:instance_variable_set)
+                                  .with(:@sn_current_navigation_2, :key)
+            simple_navigation.handle_explicit_navigation
           end
         end
-        context 'hash with multiple_levels' do
-          before(:each) do
-            args :level_2 => :key, :level_1 => :bla
-          end
-          it "should set the correct instance var in the controller" do
-            @controller.should_receive(:instance_variable_set).with(:@sn_current_navigation_2, :key)
-            SimpleNavigation.handle_explicit_navigation
+
+        context 'when the argument is a multiple levels hash' do
+          before { args level_2: :key, level_1: :bla }
+
+          it 'sets the correct instance var in the controller' do
+            expect(controller).to receive(:instance_variable_set)
+                                  .with(:@sn_current_navigation_2, :key)
+            simple_navigation.handle_explicit_navigation
           end
         end
       end
-      context 'without explicit navigation set' do
-        before(:each) do
-          args nil
-        end
-        it "should not set the current_navigation instance var in the controller" do
-          @controller.should_not_receive(:instance_variable_set)
-          SimpleNavigation.handle_explicit_navigation
+
+      context 'when no explicit navigation is set' do
+        before { args nil }
+
+        it "doesn't set the current_navigation instance var in the controller" do
+          expect(controller).not_to receive(:instance_variable_set)
+          simple_navigation.handle_explicit_navigation
         end
       end
     end
 
-    describe 'current_navigation_for' do
-      before(:each) do
-        @controller = stub(:controller)
-        @adapter = stub(:adapter, :controller => @controller)
-        SimpleNavigation.stub!(:adapter => @adapter)
-      end
-      it "should access the correct instance_var in the controller" do
-        @controller.should_receive(:instance_variable_get).with(:@sn_current_navigation_1)
-        SimpleNavigation.current_navigation_for(1)
+    describe '#current_navigation_for' do
+      it 'accesses the correct instance var in the controller' do
+        expect(controller).to receive(:instance_variable_get)
+                              .with(:@sn_current_navigation_1)
+        simple_navigation.current_navigation_for(1)
       end
     end
+  end
 
-  end  
+  describe Item do
+    let(:item) { Item.new(item_container, :my_key, 'name', 'url', {}) }
+    let(:item_container) { double(:item_container, level: 1) }
+    let(:simple_navigation) { SimpleNavigation }
 
-  describe SimpleNavigation::Item do
-    before(:each) do
-      @item_container = stub(:item_container, :level => 1)
-      @item = SimpleNavigation::Item.new(@item_container, :my_key, 'name', 'url', {})
-      
+    before do
+      item_container.stub(:dom_attributes=)
+      simple_navigation.stub(current_navigation_for: navigation_key)
     end
-    describe 'selected_by_config?' do
-      context 'navigation explicitly set' do
-        it "should return true if current matches key" do
-          SimpleNavigation.stub!(:current_navigation_for => :my_key)
-          @item.should be_selected_by_config
+
+    describe '#selected_by_config?' do
+      context 'when the navigation explicitly set' do
+        context 'when current matches the key' do
+          let(:navigation_key) { :my_key }
+
+          it 'selects the item' do
+            expect(item).to be_selected_by_config
+          end
         end
-        it "should return false if current does not match key" do
-          SimpleNavigation.stub!(:current_navigation_for => :other_key)
-          @item.should_not be_selected_by_config
+
+        context "when current doesn't match the key" do
+          let(:navigation_key) { :other_key }
+
+          it "doesn't select the item" do
+            expect(item).not_to be_selected_by_config
+          end
         end
       end
-      context 'navigation not explicitly set' do
-        before(:each) do
-          SimpleNavigation.stub!(:current_navigation_for => nil)
+
+      context 'when the navigation is not explicitly set' do
+        let(:navigation_key) { nil }
+
+        it "doesn't select the item" do
+          expect(item).not_to be_selected_by_config
         end
-        it {@item.should_not be_selected_by_config}
       end
     end
   end
-  
-  describe SimpleNavigation::ItemContainer do
-    describe 'selected_item' do
-      before(:each) do
-        SimpleNavigation.stub!(:current_navigation_for)
-        @item_container = SimpleNavigation::ItemContainer.new
-        
-        @item_1 = stub(:item, :selected? => false)
-        @item_2 = stub(:item, :selected? => false)
-        @item_container.instance_variable_set(:@items, [@item_1, @item_2])
+
+  describe ItemContainer do
+    describe '#selected_item' do
+      let(:item_container) { SimpleNavigation::ItemContainer.new }
+      let(:item_1) { double(:item, selected?: false) }
+      let(:item_2) { double(:item, selected?: false) }
+
+      before do
+        SimpleNavigation.stub(:current_navigation_for)
+        item_container.instance_variable_set(:@items, [item_1, item_2])
       end
-      context 'navigation explicitely set' do
-        before(:each) do
-          @item_container.stub!(:[] => @item_1)
-        end
-        it "should return the explicitely selected item" do
-          @item_container.selected_item.should == @item_1
+
+      context 'when a navigation is explicitely set' do
+        before { item_container.stub(:[] => item_1) }
+
+        it 'returns the explicitely selected item' do
+          expect(item_container.selected_item).to be item_1
         end
       end
-      context 'navigation not explicitely set' do
-        before(:each) do
-          @item_container.stub!(:[] => nil)
-        end
-        context 'no item selected' do
-          it "should return nil" do
-            @item_container.selected_item.should be_nil
+
+      context 'when no navigation is explicitely set' do
+        before { item_container.stub(:[] => nil) }
+
+        context 'and no item is selected' do
+          it 'returns nil' do
+            expect(item_container.selected_item).to be_nil
           end
         end
-        context 'one item selected' do
-          before(:each) do
-            @item_1.stub!(:selected? => true)
-          end
-          it "should return the selected item" do
-            @item_container.selected_item.should == @item_1
+
+        context 'and one item is selected' do
+          before { item_1.stub(selected?: true) }
+
+          it 'returns the selected item' do
+            expect(item_container.selected_item).to be item_1
           end
         end
       end
     end
-    
   end
-  
 end
-