simple-navigation 3.11.0 → 3.12.0

data/spec/lib/simple_navigation/rendering/helpers_spec.rb

@@ -1,276 +1,432 @@
 require 'spec_helper'
 
-describe SimpleNavigation::Helpers do
-  class ControllerMock
-    include SimpleNavigation::Helpers
-  end
+class TestController
+  include SimpleNavigation::Helpers
+end
 
-  def blackbox_setup()
-    @controller = ControllerMock.new
-    SimpleNavigation.stub!(:load_config)
-    SimpleNavigation::Configuration.stub!(:eval_config)
-    setup_adapter_for :rails
-    @primary_container, @subnav_container = containers
-    @subnav1_item = sub_item(:subnav1)
-    @invoices_item = primary_item(:invoices)
-    SimpleNavigation.stub!(:primary_navigation => @primary_container)
-  end
+module SimpleNavigation
+  describe Helpers do
+    subject(:controller) { TestController.new }
 
-  def whitebox_setup
-    @controller = ControllerMock.new
-    SimpleNavigation.stub!(:load_config)
-    SimpleNavigation::Configuration.stub!(:eval_config)
-    @primary_navigation = stub(:primary_navigation).as_null_object
-    SimpleNavigation.stub!(:primary_navigation).and_return(@primary_navigation)
-    SimpleNavigation.stub!(:config_file? => true)
-  end
+    let(:invoices_item) { navigation[:invoices] }
+    let(:item) { nil }
+    let(:navigation) { setup_navigation('nav_id', 'nav_class') }
+    let(:unpaid_item) { invoices_item.sub_navigation[:unpaid] }
+
+    before do
+      Configuration.stub(:eval_config)
+      SimpleNavigation.stub(load_config: nil,
+                            primary_navigation: navigation,
+                            config_file?: true,
+                            context_for_eval: controller)
 
-  describe 'active_navigation_item_name' do
-    before(:each) do
-      blackbox_setup
+      select_an_item(navigation[item]) if item
     end
-    context 'active item_container for desired level exists' do
-      context 'container has selected item' do
-        before(:each) do
-          select_item(:subnav1)
-        end
-        it {@controller.active_navigation_item_name(:level => 2).should == 'subnav1'}
-        it {@controller.active_navigation_item_name.should == 'subnav1'}
-        it {@controller.active_navigation_item_name(:level => 1).should == 'invoices'}
-        it {@controller.active_navigation_item_name(:level => :all).should == 'subnav1'}
-      end
-      context 'container does not have selected item' do
-        it {@controller.active_navigation_item_name.should == ''}
-      end
-      context 'custom name generator set' do
-        before(:each) do
-          select_item(:subnav1)
-          SimpleNavigation.config.stub!(:name_generator => Proc.new {|name| "<span>name</span>"})
+
+    describe '#active_navigation_item_name' do
+      context 'when no item is selected' do
+        it 'returns an empty string for no parameters' do
+          expect(controller.active_navigation_item_name).to eq ''
         end
-        it "should not apply the generator" do
-          @controller.active_navigation_item_name(:level => 1).should == 'invoices'
+
+        it "returns an empty string for level: 1" do
+          item_name = controller.active_navigation_item_name(level: 1)
+          expect(item_name).to eq ''
         end
-      end
-    end
-    context 'no active item_container for desired level' do
-      it {@controller.active_navigation_item_name(:level => 5).should == ''}
-    end
-  end
 
-  describe 'active_navigation_item_key' do
-    before(:each) do
-      blackbox_setup
-    end
-    context 'active item_container for desired level exists' do
-      context 'container has selected item' do
-        before(:each) do
-          select_item(:subnav1)
-        end
-        it {@controller.active_navigation_item_key(:level => 2).should == :subnav1}
-        it {@controller.active_navigation_item_key.should == :subnav1}
-        it {@controller.active_navigation_item_key(:level => 1).should == :invoices}
-        it {@controller.active_navigation_item_key(:level => :all).should == :subnav1}
+        it 'returns an empty string for level: 2' do
+          item_name = controller.active_navigation_item_name(level: 2)
+          expect(item_name).to eq ''
+        end
+
+        it 'returns an empty string for level: :all' do
+          item_name = controller.active_navigation_item_name(level: :all)
+          expect(item_name).to eq ''
+        end
       end
-      context 'container does not have selected item' do
-        it {@controller.active_navigation_item_key.should == nil}
+
+      context 'when an item is selected' do
+        context "and it's a primary item" do
+          let(:item) { :invoices }
+
+          it 'returns an empty string' do
+            expect(controller.active_navigation_item_name).to eq ''
+          end
+
+          it "returns the selected item's name for level: 1" do
+            item_name = controller.active_navigation_item_name(level: 1)
+            expect(item_name).to eq 'Invoices'
+          end
+
+          it 'returns an empty string for level: 2' do
+            item_name = controller.active_navigation_item_name(level: 2)
+            expect(item_name).to eq ''
+          end
+
+          it 'returns an empty string for level: :all' do
+            item_name = controller.active_navigation_item_name(level: :all)
+            expect(item_name).to eq ''
+          end
+        end
+
+        context "and it's a sub navigation item" do
+          before do
+            select_an_item(invoices_item)
+            select_an_item(unpaid_item)
+          end
+
+          it "returns the selected item's name" do
+            expect(controller.active_navigation_item_name).to eq 'Unpaid'
+          end
+
+          it "returns the selected item's parent name for level: 1" do
+            item_name = controller.active_navigation_item_name(level: 1)
+            expect(item_name).to eq 'Invoices'
+          end
+
+          it "returns the selected item's name for level: 2" do
+            item_name = controller.active_navigation_item_name(level: 2)
+            expect(item_name).to eq 'Unpaid'
+          end
+
+          it "returns the selected item's name for level: :all" do
+            item_name = controller.active_navigation_item_name(level: :all)
+            expect(item_name).to eq 'Unpaid'
+          end
+        end
       end
     end
-    context 'no active item_container for desired level' do
-      it {@controller.active_navigation_item_key(:level => 5).should == nil}
-    end
-  end
 
-  describe 'active_navigation_item' do
-    before(:each) do
-      blackbox_setup
-    end
-    context 'active item_container for desired level exists' do
-      context 'container has selected item' do
-        before(:each) do
-          select_item(:subnav1)
-        end
-        it {@controller.active_navigation_item(:level => 2).should eq(@subnav1_item)}
-        it {@controller.active_navigation_item.should eq(@subnav1_item)}
-        it {@controller.active_navigation_item(:level => 1).should eq(@invoices_item)}
-        it {@controller.active_navigation_item(:level => :all).should eq(@subnav1_item)}
-      end
-      context 'container does not have selected item' do
-        context 'return value defaults to nil' do
-          it {@controller.active_navigation_item.should == nil}
+    describe '#active_navigation_item_key' do
+      context 'when no item is selected' do
+        it 'returns nil' do
+          expect(controller.active_navigation_item_key).to be_nil
         end
-        context 'return value reflects passed in value' do
-          it {@controller.active_navigation_item({},'none').should == 'none'}
-          it {@controller.active_navigation_item({},@invoices_item).should eq(@invoices_item)}
+
+        it 'returns nil for no parameters' do
+          expect(controller.active_navigation_item_key).to be_nil
+        end
+
+        it "returns nil for level: 1" do
+          item_key = controller.active_navigation_item_key(level: 1)
+          expect(item_key).to be_nil
+        end
+
+        it 'returns nil for level: 2' do
+          item_key = controller.active_navigation_item_key(level: 2)
+          expect(item_key).to be_nil
+        end
+
+        it 'returns nil for level: :all' do
+          item_key = controller.active_navigation_item_key(level: :all)
+          expect(item_key).to be_nil
         end
       end
-    end
-    context 'no active item_container for desired level' do
-      it {@controller.active_navigation_item(:level => 5).should == nil}
-    end
-  end
 
-  describe 'active_navigation_item_container' do
-    before(:each) do
-      blackbox_setup
-    end
-    context 'active item_container for desired level exists' do
-      before(:each) do
-        select_item(:subnav1)
+      context 'when an item is selected' do
+        context "and it's a primary item" do
+          let(:item) { :invoices }
+
+          it 'returns nil for no parameters' do
+            expect(controller.active_navigation_item_key).to be_nil
+          end
+
+          it "returns the selected item's name for level: 1" do
+            item_key = controller.active_navigation_item_key(level: 1)
+            expect(item_key).to eq :invoices
+          end
+
+          it 'returns nil for level: 2' do
+            item_key = controller.active_navigation_item_key(level: 2)
+            expect(item_key).to be_nil
+          end
+
+          it 'returns nil for level: :all' do
+            item_key = controller.active_navigation_item_key(level: :all)
+            expect(item_key).to be_nil
+          end
+        end
+
+        context "and it's a sub navigation item" do
+          before do
+            select_an_item(invoices_item)
+            select_an_item(unpaid_item)
+          end
+
+          it "returns the selected item's name" do
+            expect(controller.active_navigation_item_key).to eq :unpaid
+          end
+
+          it "returns the selected item's parent name for level: 1" do
+            item_key = controller.active_navigation_item_key(level: 1)
+            expect(item_key).to eq :invoices
+          end
+
+          it "returns the selected item's name for level: 2" do
+            item_key = controller.active_navigation_item_key(level: 2)
+            expect(item_key).to eq :unpaid
+          end
+
+          it "returns the selected item's name for level: :all" do
+            item_key = controller.active_navigation_item_key(level: :all)
+            expect(item_key).to eq :unpaid
+          end
+        end
       end
-      it {@controller.active_navigation_item_container(:level => 2).should == @subnav_container}
-      it {@controller.active_navigation_item_container.should == @primary_container}
-      it {@controller.active_navigation_item_container(:level => 1).should == @primary_container}
-      it {@controller.active_navigation_item_container(:level => :all).should == @primary_container}
     end
-    context 'no active item_container for desired level' do
-      it {@controller.active_navigation_item_container(:level => 5).should == nil}
-    end
-  end
 
-  describe 'render_navigation' do
-  
-    before(:each) do
-      whitebox_setup
-    end
-  
-    describe 'regarding loading of the config-file' do
-      context 'no options specified' do
-        it "should load the config-file for the default context" do
-          SimpleNavigation.should_receive(:load_config).with(:default)
-          @controller.render_navigation
+    describe '#active_navigation_item' do
+      context 'when no item is selected' do
+        it 'returns nil for no parameters' do
+          expect(controller.active_navigation_item).to be_nil
+        end
+
+        it "returns nil for level: 1" do
+          item_key = controller.active_navigation_item(level: 1)
+          expect(item_key).to be_nil
+        end
+
+        it 'returns nil for level: 2' do
+          item_key = controller.active_navigation_item(level: 2)
+          expect(item_key).to be_nil
+        end
+
+        it 'returns nil for level: :all' do
+          item_key = controller.active_navigation_item(level: :all)
+          expect(item_key).to be_nil
         end
       end
-  
-      context 'with options specified' do
-        it "should load the config-file for the specified context" do
-          SimpleNavigation.should_receive(:load_config).with(:my_context)
-          @controller.render_navigation(:context => :my_context)
+
+      context 'when an item is selected' do
+        context "and it's a primary item" do
+          let(:item) { :invoices }
+
+          it 'returns nil for no parameters' do
+            expect(controller.active_navigation_item).to be_nil
+          end
+
+          it "returns the selected item's name for level: 1" do
+            item_key = controller.active_navigation_item(level: 1)
+            expect(item_key).to be invoices_item
+          end
+
+          it 'returns nil for level: 2' do
+            item_key = controller.active_navigation_item(level: 2)
+            expect(item_key).to be_nil
+          end
+
+          it 'returns nil for level: :all' do
+            item_key = controller.active_navigation_item(level: :all)
+            expect(item_key).to be_nil
+          end
+        end
+
+        context "and it's a sub navigation item" do
+          before do
+            select_an_item(invoices_item)
+            select_an_item(unpaid_item)
+          end
+
+          it "returns the selected item's name for no parameters" do
+            expect(controller.active_navigation_item).to be unpaid_item
+          end
+
+          it "returns the selected item's parent name for level: 1" do
+            item_key = controller.active_navigation_item(level: 1)
+            expect(item_key).to be invoices_item
+          end
+
+          it "returns the selected item's name for level: 2" do
+            item_key = controller.active_navigation_item(level: 2)
+            expect(item_key).to eq unpaid_item
+          end
+
+          it "returns the selected item's name for level: :all" do
+            item_key = controller.active_navigation_item(level: :all)
+            expect(item_key).to eq unpaid_item
+          end
         end
       end
     end
-  
-    it "should eval the config on every request" do
-      SimpleNavigation::Configuration.should_receive(:eval_config).with(:default)
-      @controller.render_navigation
-    end
-  
-    describe 'regarding setting of items' do
-      context 'not items specified in options' do
-        it "should not set the items directly" do
-          SimpleNavigation.config.should_not_receive(:items)
-          @controller.render_navigation
+
+    describe '#active_navigation_item_container' do
+      shared_examples 'returning items container' do
+        it 'returns the primary navigation for no parameters' do
+          expect(controller.active_navigation_item_container).to be navigation
         end
-      end
-      context 'items specified in options' do
-        before(:each) do
-          @items = stub(:items)
+
+        it "returns the primary navigation for level: 1" do
+          item_container = controller.active_navigation_item_container(level: 1)
+          expect(item_container).to be navigation
         end
-        it "should set the items directly" do
-          SimpleNavigation.config.should_receive(:items).with(@items)
-          @controller.render_navigation(:items => @items)
+
+        it 'returns the primary navigation level: :all' do
+          item_container =
+            controller.active_navigation_item_container(level: :all)
+          expect(item_container).to be navigation
         end
       end
-      context 'block given' do
-        it 'should use block' do
-          block_executed = 0
-          expect do
-            @controller.render_navigation do |menu|
-              menu.class.should == SimpleNavigation::ItemContainer
-              block_executed += 1
-            end
-          end.to change{block_executed}.by(1)
+
+      context 'when no item is selected' do
+        it_behaves_like 'returning items container'
+
+        it 'returns nil for level: 2' do
+          item_container = controller.active_navigation_item_container(level: 2)
+          expect(item_container).to be_nil
         end
       end
-    end
-  
-    describe 'no primary navigation defined' do
-      before(:each) do
-        SimpleNavigation.stub!(:primary_navigation => nil)
+
+      context 'when an item is selected' do
+        context "and it's a primary item" do
+          let(:item) { :invoices }
+
+          it_behaves_like 'returning items container'
+
+          it 'returns the invoices items container for level: 2' do
+            item_container =
+              controller.active_navigation_item_container(level: 2)
+            expect(item_container).to be invoices_item.sub_navigation
+          end
+        end
+
+        context "and it's a sub navigation item" do
+          before do
+            select_an_item(invoices_item)
+            select_an_item(unpaid_item)
+          end
+
+          it_behaves_like 'returning items container'
+
+          it 'returns the invoices items container for level: 2' do
+            item_container =
+              controller.active_navigation_item_container(level: 2)
+            expect(item_container).to be invoices_item.sub_navigation
+          end
+        end
       end
-      it {lambda {@controller.render_navigation}.should raise_error}
     end
-  
-    context 'rendering of the item_container' do
-      before(:each) do
-        @active_item_container = stub(:item_container).as_null_object
-        SimpleNavigation.stub!(:active_item_container_for => @active_item_container)
+
+    describe '#render_navigation' do
+      it 'evaluates the configuration on every request' do
+        expect(SimpleNavigation).to receive(:load_config).twice
+        2.times { controller.render_navigation }
       end
-      it "should lookup the active_item_container based on the level" do
-        SimpleNavigation.should_receive(:active_item_container_for).with(:all)
-        @controller.render_navigation
+
+      it 'loads the :default configuration' do
+        expect(SimpleNavigation).to receive(:load_config).with(:default)
+        controller.render_navigation
       end
-      context 'active_item_container is nil' do
-        before(:each) do
-          SimpleNavigation.stub!(:active_item_container_for => nil)
-        end
-        it "should not call render" do
-          @active_item_container.should_not_receive(:render)
-          @controller.render_navigation
-        end
+
+      it "doesn't set the items directly" do
+        expect(SimpleNavigation.config).not_to receive(:items)
+        controller.render_navigation
+      end
+
+      it 'looks up the active_item_container based on the level' do
+        expect(SimpleNavigation).to receive(:active_item_container_for)
+                                    .with(:all)
+        controller.render_navigation
       end
-      context 'active_item_container is not nil' do
-        it "should call render on the container" do
-          @active_item_container.should_receive(:render)
-          @controller.render_navigation
+
+      context 'when the :context option is specified' do
+        it 'loads the configuration for the specified context' do
+          expect(SimpleNavigation).to receive(:load_config).with(:my_context)
+          controller.render_navigation(context: :my_context)
         end
       end
-    end
-  
-    context 'primary' do
-      it "should call render on the primary_navigation (specifying level through options)" do
-        @primary_navigation.should_receive(:render).with(:level => 1)
-        @controller.render_navigation(:level => 1)
+
+      context 'when the :items option is specified' do
+        let(:items) { double(:items) }
+
+        it 'sets the items directly' do
+          expect(SimpleNavigation.config).to receive(:items).with(items)
+          controller.render_navigation(items: items)
+        end
       end
-    end
-  
-    context 'secondary' do
-      context 'with current_primary_navigation set' do
-        before(:each) do
-          @selected_item_container = stub(:selected_container).as_null_object
-          SimpleNavigation.stub!(:active_item_container_for => @selected_item_container)
+
+      context 'when the :level option is set' do
+        context 'and its value is 1' do
+          it 'calls render on the primary navigation' do
+            expect(navigation).to receive(:render).with(level: 1)
+            controller.render_navigation(level: 1)
+          end
         end
-        it "should find the selected sub_navigation for the specified level" do
-          SimpleNavigation.should_receive(:active_item_container_for).with(2)
-          @controller.render_navigation(:level => 2)
+
+        context 'and its value is 2' do
+          context 'and the active_item_container is set' do
+            let(:item_container) { double(:container).as_null_object }
+
+            before do
+              SimpleNavigation.stub(active_item_container_for: item_container)
+            end
+
+            it 'finds the selected sub navigation for the specified level' do
+              expect(SimpleNavigation).to receive(:active_item_container_for)
+                                            .with(2)
+              controller.render_navigation(level: 2)
+            end
+
+            it 'calls render on the active item_container' do
+              expect(item_container).to receive(:render).with(level: 2)
+              controller.render_navigation(level: 2)
+            end
+          end
+
+          context "and the active_item_container isn't set" do
+            it "doesn't raise an exception" do
+              expect{
+                controller.render_navigation(level: 2)
+              }.not_to raise_error
+            end
+          end
         end
-        it "should find the selected sub_navigation for the specified level" do
-          SimpleNavigation.should_receive(:active_item_container_for).with(1)
-          @controller.render_navigation(:level => 1)
+
+        context "and its value isn't a valid level" do
+          it 'raises an exception' do
+            expect{
+              controller.render_navigation(level: :invalid)
+            }.to raise_error
+          end
         end
-        it "should call render on the active item_container" do
-          @selected_item_container.should_receive(:render).with(:level => 2)
-          @controller.render_navigation(:level => 2)
+      end
+
+      context 'when the :levels option is set' do
+        before { SimpleNavigation.stub(active_item_container_for: navigation) }
+
+        it 'treats it like the :level option' do
+          expect(navigation).to receive(:render).with(level: 2)
+          controller.render_navigation(levels: 2)
         end
       end
-      context 'without an active item_container set' do
-        before(:each) do
-          SimpleNavigation.stub!(:active_item_container_for => nil)
+
+      context 'when a block is given' do
+        it 'calls the block passing it an item container' do
+          expect{ |blk|
+            controller.render_navigation(&blk)
+          }.to yield_with_args(ItemContainer)
         end
-        it "should not raise an error" do
-          lambda {@controller.render_navigation(:level => 2)}.should_not raise_error
+      end
+
+      context 'when no primary configuration is defined' do
+        before { SimpleNavigation.stub(primary_navigation: nil) }
+
+        it 'raises an exception' do
+          expect{controller.render_navigation}.to raise_error
         end
       end
-  
-    end
-  
-    context 'unknown level' do
-      it "should raise an error" do
-        lambda {@controller.render_navigation(:level => :unknown)}.should raise_error(ArgumentError)
+
+      context "when active_item_container is set" do
+        let(:active_item_container) { double(:container).as_null_object }
+
+        before do
+          SimpleNavigation.stub(active_item_container_for: active_item_container)
+        end
+
+        it 'calls render on the active_item_container' do
+          expect(active_item_container).to receive(:render)
+          controller.render_navigation
+        end
       end
     end
-  
   end
-  
-  describe "should treat :level and :levels options the same" do
-    before(:each) do
-      whitebox_setup
-      @selected_item_container = stub(:selected_container).as_null_object
-      SimpleNavigation.stub!(:active_item_container_for => @selected_item_container)
-    end
-    it  "should pass a valid levels options as level" do
-      @selected_item_container.should_receive(:render).with(:level => 2)
-      @controller.render_navigation(:levels => 2)
-    end
-  end
-
 end