simple-navigation 3.11.0 → 3.12.0

data/spec/lib/simple_navigation/rendering/renderer/base_spec.rb

@@ -1,199 +1,240 @@
 require 'spec_helper'
 
-describe SimpleNavigation::Renderer::Base do
-  before(:each) do
-    @options = stub(:options).as_null_object
-    @adapter = stub(:adapter)
-    SimpleNavigation.stub!(:adapter => @adapter)
-    @base_renderer = SimpleNavigation::Renderer::Base.new(@options)
-  end
-  
-  describe 'delegated methods' do
-    it {@base_renderer.should respond_to(:link_to)}
-    it {@base_renderer.should respond_to(:content_tag)}
-  end
+module SimpleNavigation
+  module Renderer
+    describe Base do
+      subject(:base) { Base.new(options) }
 
-  describe 'initialize' do
-    it {@base_renderer.adapter.should == @adapter}
-    it {@base_renderer.options.should == @options}
-  end
-    
-  describe 'render' do
-    it "be subclass responsability" do
-      lambda {@base_renderer.render(:container)}.should raise_error('subclass responsibility')
-    end
-  end
-    
-  describe 'expand_all?' do
-    context 'option is set' do
-      context 'expand_all is true' do
-        before(:each) do
-          @base_renderer.stub!(:options => {:expand_all => true})
-        end
-        it {@base_renderer.expand_all?.should be_true}
-      end
-      context 'expand_all is false' do
-        before(:each) do
-          @base_renderer.stub!(:options => {:expand_all => false})
-        end
-        it {@base_renderer.expand_all?.should be_false}
-      end
-    end
-    context 'option is not set' do
-      before(:each) do
-        @base_renderer.stub!(:options => {})
-      end
-      it {@base_renderer.expand_all?.should be_false}
-    end
-  end
+      let(:adapter) { double(:adapter) }
+      let(:options) { Hash.new }
 
-  describe 'skip_if_empty?' do
-    context 'option is set' do
-      context 'skip_if_empty is true' do
-        before(:each) do
-          @base_renderer.stub!(:options => {:skip_if_empty => true})
-        end
-        it {@base_renderer.skip_if_empty?.should be_true}
-      end
-      context 'skip_if_empty is false' do
-        before(:each) do
-          @base_renderer.stub!(:options => {:skip_if_empty => false})
-        end
-        it {@base_renderer.skip_if_empty?.should be_false}
-      end
-    end
-    context 'option is not set' do
-      before(:each) do
-        @base_renderer.stub!(:options => {})
-      end
-      it {@base_renderer.skip_if_empty?.should be_false}
-    end
-  end
+      before { SimpleNavigation.stub(adapter: adapter) }
 
-  describe 'level' do
-    context 'options[level] is set' do
-      before(:each) do
-        @base_renderer.stub!(:options => {:level => 1})
+      it 'delegates the :link_to method to adapter' do
+        adapter.stub(link_to: 'link_to')
+        expect(base.link_to).to eq 'link_to'
       end
-      it {@base_renderer.level.should == 1}
-    end
-    context 'options[level] is not set' do
-      before(:each) do
-        @base_renderer.stub!(:options => {})
-      end
-      it {@base_renderer.level.should == :all}
-    end
-  end
 
-  describe 'consider_sub_navigation?' do
-    before(:each) do
-      @item = stub(:item)
-    end
-    context 'item has no subnavigation' do
-      before(:each) do
-        @item.stub!(:sub_navigation => nil)
+      it 'delegates the :content_tag method to adapter' do
+        adapter.stub(content_tag: 'content_tag')
+        expect(base.content_tag).to eq 'content_tag'
       end
-      it {@base_renderer.send(:consider_sub_navigation?, @item).should be_false}
-    end
-    context 'item has subnavigation' do
-      before(:each) do
-        @sub_navigation = stub(:sub_navigation)
-        @item.stub!(:sub_navigation => @sub_navigation)
-      end
-      context 'level is something unknown' do
-        before(:each) do
-          @base_renderer.stub!(:level => 'unknown')
+
+      describe '#initialize' do
+        it "sets the renderer adapter to the SimpleNavigation one" do
+          expect(base.adapter).to be adapter
         end
-        it {@base_renderer.send(:consider_sub_navigation?, @item).should be_false}
       end
-      context 'level is :all' do
-        before(:each) do
-          @base_renderer.stub!(:level => :all)
+
+      describe '#options' do
+        it "returns the renderer's options" do
+          expect(base.options).to be options
         end
-        it {@base_renderer.send(:consider_sub_navigation?, @item).should be_true}
       end
-      context 'level is an Integer' do
-        before(:each) do
-          @base_renderer.stub!(:level => 2)
+
+      describe '#render' do
+        it "raise an exception to indicate it's a subclass responsibility" do
+          expect{ base.render(:container) }.to raise_error
         end
-        it {@base_renderer.send(:consider_sub_navigation?, @item).should be_false}
       end
-      context 'level is a Range' do
-        before(:each) do
-          @base_renderer.stub!(:level => 2..3)
+
+      describe '#expand_all?' do
+        context 'when :options is set' do
+          context 'and the :expand_all option is true' do
+            let(:options) {{ expand_all: true }}
+
+            it 'returns true' do
+              expect(base.expand_all?).to be_true
+            end
+          end
+
+          context 'and the :expand_all option is false' do
+            let(:options) {{ expand_all: false }}
+
+            it 'returns false' do
+              expect(base.expand_all?).to be_false
+            end
+          end
         end
-        context 'subnavs level > range.max' do
-          before(:each) do
-            @sub_navigation.stub!(:level => 4)
+
+        context "when :options isn't set" do
+          let(:options) { Hash.new }
+
+          it 'returns false' do
+            expect(base.expand_all?).to be_false
           end
-          it {@base_renderer.send(:consider_sub_navigation?, @item).should be_false}
         end
-        context 'subnavs level = range.max' do
-          before(:each) do
-            @sub_navigation.stub!(:level => 3)
+      end
+
+      describe '#skip_if_empty?' do
+        context 'when :options is set' do
+          context 'and the :skip_if_empty option is true' do
+            let(:options) {{ skip_if_empty: true }}
+
+            it 'returns true' do
+              expect(base.skip_if_empty?).to be_true
+            end
           end
-          it {@base_renderer.send(:consider_sub_navigation?, @item).should be_true}
 
+          context 'and the :skip_if_empty option is false' do
+            let(:options) {{ skip_if_empty: false }}
+
+            it 'returns true' do
+              expect(base.skip_if_empty?).to be_false
+            end
+          end
         end
-        context 'subnavs level < range.max' do
-          before(:each) do
-            @sub_navigation.stub!(:level => 2)
+
+        context "when :options isn't set" do
+          let(:options) { Hash.new }
+
+          it 'returns true' do
+            expect(base.skip_if_empty?).to be_false
           end
-          it {@base_renderer.send(:consider_sub_navigation?, @item).should be_true}
         end
       end
-    end
-  end
 
-  describe 'include_sub_navigation?' do
-    before(:each) do
-      @item = stub(:item)
-    end
-    context 'consider_sub_navigation? is true' do
-      before(:each) do
-        @base_renderer.stub!(:consider_sub_navigation? => true)
-      end
-      context 'expand_sub_navigation? is true' do
-        before(:each) do
-          @base_renderer.stub!(:expand_sub_navigation? => true)
+      describe '#level' do
+        context 'and the :level option is set' do
+          let(:options) {{ level: 1 }}
+
+          it 'returns the specified level' do
+            expect(base.level).to eq 1
+          end
         end
-        it {@base_renderer.include_sub_navigation?(@item).should be_true}
-      end
-      context 'expand_sub_navigation? is false' do
-        before(:each) do
-          @base_renderer.stub!(:expand_sub_navigation? => false)
+
+        context "and the :level option isn't set" do
+          let(:options) { Hash.new }
+
+          it 'returns :all' do
+            expect(base.level).to eq :all
+          end
         end
-        it {@base_renderer.include_sub_navigation?(@item).should be_false}
       end
-    end
-    context 'consider_sub_navigation is false' do
-      before(:each) do
-        @base_renderer.stub!(:consider_sub_navigation? => false)
-      end
-      context 'expand_sub_navigation? is true' do
-        before(:each) do
-          @base_renderer.stub!(:expand_sub_navigation? => true)
+
+      describe '#consider_sub_navigation?' do
+        let(:item) { double(:item) }
+
+        before { item.stub(sub_navigation: sub_navigation) }
+
+        context 'when the item has no sub navigation' do
+          let(:sub_navigation) { nil }
+
+          it 'returns false' do
+            expect(base.send(:consider_sub_navigation?, item)).to be_false
+          end
+        end
+
+        context 'when the item has sub navigation' do
+          let(:sub_navigation) { double(:sub_navigation) }
+
+          context 'and the renderer has an unknown level' do
+            before { base.stub(level: 'unknown') }
+
+            it 'returns false' do
+              expect(base.send(:consider_sub_navigation?, item)).to be_false
+            end
+          end
+
+          context 'and the renderer has a level set to :all' do
+            before { base.stub(level: :all) }
+
+            it 'returns false' do
+              expect(base.send(:consider_sub_navigation?, item)).to be_true
+            end
+          end
+
+          context "when the renderer's level is a number" do
+            before { base.stub(level: 2) }
+
+            it 'returns false' do
+              expect(base.send(:consider_sub_navigation?, item)).to be_false
+            end
+          end
+
+          context "when the renderer's level is a Range" do
+            before { base.stub(level: 2..3) }
+
+            context "and sub navigation's level is greater than range.max" do
+              before { sub_navigation.stub(level: 4) }
+
+              it 'returns false' do
+                expect(base.send(:consider_sub_navigation?, item)).to be_false
+              end
+            end
+
+            context "and sub navigation's level is equal to range.max" do
+              before { sub_navigation.stub(level: 3) }
+
+              it 'returns true' do
+                expect(base.send(:consider_sub_navigation?, item)).to be_true
+              end
+            end
+
+            context "and sub navigation's level is equal to range.min" do
+              before { sub_navigation.stub(level: 2) }
+
+              it 'returns true' do
+                expect(base.send(:consider_sub_navigation?, item)).to be_true
+              end
+            end
+          end
         end
-        it {@base_renderer.include_sub_navigation?(@item).should be_false}
       end
-      context 'expand_sub_navigation? is false' do
-        before(:each) do
-          @base_renderer.stub!(:expand_sub_navigation? => false)
+
+      describe '#include_sub_navigation?' do
+        let(:item) { double(:item) }
+
+        context 'when consider_sub_navigation? is true' do
+          before { base.stub(consider_sub_navigation?: true) }
+
+          context 'and expand_sub_navigation? is true' do
+            before { base.stub(expand_sub_navigation?: true) }
+
+            it 'returns true' do
+              expect(base.include_sub_navigation?(item)).to be_true
+            end
+          end
+
+          context 'and expand_sub_navigation? is false' do
+            before { base.stub(expand_sub_navigation?: false) }
+
+            it 'returns false' do
+              expect(base.include_sub_navigation?(item)).to be_false
+            end
+          end
+        end
+
+        context 'consider_sub_navigation? is false' do
+          before { base.stub(consider_sub_navigation?: false) }
+
+          context 'and expand_sub_navigation? is true' do
+            before { base.stub(expand_sub_navigation?: true) }
+
+            it 'returns false' do
+              expect(base.include_sub_navigation?(item)).to be_false
+            end
+          end
+
+          context 'and expand_sub_navigation? is false' do
+            before { base.stub(expand_sub_navigation?: false) }
+
+            it 'returns false' do
+              expect(base.include_sub_navigation?(item)).to be_false
+            end
+          end
         end
-        it {@base_renderer.include_sub_navigation?(@item).should be_false}
       end
-    end
-  end
 
-  describe 'render_sub_navigation_for' do
-    before(:each) do
-      @sub_navigation = stub(:sub_navigation)
-      @item = stub(:item, :sub_navigation => @sub_navigation)
-    end
-    it "should call render on the sub_navigation (passing the options)" do
-      @sub_navigation.should_receive(:render).with(@options)
-      @base_renderer.render_sub_navigation_for(@item)
+      describe '#render_sub_navigation_for' do
+        let(:item) { double(:item, sub_navigation: sub_navigation) }
+        let(:sub_navigation) { double(:sub_navigation) }
+
+        it 'renders the sub navigation passing it the options' do
+          expect(sub_navigation).to receive(:render).with(options)
+          base.render_sub_navigation_for(item)
+        end
+      end
     end
   end
-
 end

data/spec/lib/simple_navigation/rendering/renderer/breadcrumbs_spec.rb

@@ -1,99 +1,119 @@
 require 'spec_helper'
-require 'html/document'# unless defined? HTML::Document
 
-describe SimpleNavigation::Renderer::Breadcrumbs do
+module SimpleNavigation
+  module Renderer
+    describe Breadcrumbs do
+      let!(:navigation) { setup_navigation('nav_id', 'nav_class') }
 
-  describe 'render' do
+      let(:item) { nil }
+      let(:options) {{ level: :all }}
+      let(:output) { HTML::Document.new(raw_output).root }
+      let(:raw_output) { renderer.render(navigation) }
+      let(:renderer) { setup_renderer(Breadcrumbs, options) }
 
-    def render(current_nav=nil, options={:level => :all})
-      primary_navigation = primary_container
-      select_item(current_nav) if current_nav
-      setup_renderer_for SimpleNavigation::Renderer::Breadcrumbs, :rails, options
-      HTML::Document.new(@renderer.render(primary_navigation)).root
-    end
-
-    context 'regarding result' do
+      before { select_an_item(navigation[item]) if item }
 
-      it "should render a div-tag around the items" do
-          HTML::Selector.new('div').select(render).should have(1).entries
+      describe '#render' do
+        it "renders a 'div' tag for the navigation" do
+          expect(output).to have_css('div')
         end
-        it "the rendered div-tag should have the specified dom_id" do
-          HTML::Selector.new('div#nav_dom_id').select(render).should have(1).entries
+
+        it "sets the right html id on the rendered 'div' tag" do
+          expect(output).to have_css('div#nav_id')
         end
-        it "the rendered div-tag should have the specified class" do
-          HTML::Selector.new('div.nav_dom_class').select(render).should have(1).entries
+
+        it "sets the right html classes on the rendered 'div' tag" do
+          expect(output).to have_css('div.nav_class')
         end
 
-        context 'without current_navigation set' do
-          it "should not render any a-tag in the div-tag" do
-            HTML::Selector.new('div a').select(render).should have(0).entries
+        context 'when no item is selected' do
+          it "doesn't render any 'a' tag in the 'div' tag" do
+            expect(output).not_to have_css('div a')
           end
         end
 
-      context 'with current_navigation set' do
-        before(:each) do
-          @selection = HTML::Selector.new('div a').select(render(:invoices))
-        end
-        it "should render the selected a tags" do
-          @selection.should have(1).entries
-        end
+        context 'when an item is selected' do
+          let(:item) { :invoices }
 
-        it "should not render class or id" do
-          @selection.each do |tag|
-            raise unless tag.name == "a"
-            tag["id"].should be_nil
-            tag["class"].should be_nil
+          it "renders the selected 'a' tag" do
+            expect(output).to have_css('div a')
+          end
+
+          it "remders the 'a' tag without any html id" do
+            expect(output).not_to have_css('div a[id]')
           end
-        end
 
-        context 'with allow_classes_and_ids option' do
-          before(:each) do
-            @selection = HTML::Selector.new('div a').select(render(:users, :level => :all, :allow_classes_and_ids => true))
+          it "renders the 'a' tag without any html class" do
+            expect(output).not_to have_css('div a[class]')
           end
-          it "should render class and id" do
-            @selection.each do |tag|
-              raise unless tag.name == "a"
-              tag["id"].should_not be_nil
-              tag["class"].should_not be_nil
+
+          context 'and the :allow_classes_and_ids option is true' do
+            let(:options) {{ level: :all, allow_classes_and_ids: true }}
+
+            it "renders the 'a' tag with the selected class" do
+              expect(output).to have_css('div a.selected')
+            end
+
+            context "and the item hasn't any id explicitly set" do
+              it "renders the 'a' tag without any html id" do
+                expect(output).not_to have_css('div a[id]')
+              end
+            end
+
+            context 'and the item has an explicitly set id' do
+              let(:item) { :users }
+
+              it "renders the 'a' tag with an html id" do
+                expect(output).to have_css('div a#breadcrumb_users_link_id')
+              end
             end
           end
         end
 
-        context 'with prefix option' do
-          it 'should render prefix before breadcrumbs' do
-            selection = HTML::Selector.new('div').select(render(:subnav1, :level => :all, :prefix => 'You are here: '))
-            raise unless selection.count == 1
-            tag = selection.first
-            tag.to_s.should =~ /^\<div.+\>You are here\: /
+        context 'and the :prefix option is set' do
+          let(:options) {{ prefix: 'You are here: ' }}
+
+          context 'and there are no items to render' do
+            let(:item) { nil }
+
+            it "doesn't render the prefix before the breadcrumbs" do
+              expect(raw_output).not_to match(/^<div.+>You are here: /)
+            end
           end
 
-          it 'should not render prefix if there is no available breadcrumb' do
-            allow_message_expectations_on_nil
-            selection = HTML::Selector.new('div').select(render('', :prefix => 'You are here: '))
-            tag = selection.first
-            tag.to_s.should =~ /^\<div.+\>\<\/div\>/
+          context 'and there are items to render' do
+            let(:item) { :invoices }
+
+            it 'renders the prefix before the breadcrumbs' do
+              expect(raw_output).to match(/^<div.+>You are here: /)
+            end
           end
         end
 
-        context 'with static_leaf option' do
-          before(:each) do
-            @selection = HTML::Selector.new('div *').select(render(:subnav1, :level => :all, :static_leaf => true))
-          end
-          it "should render link for non-leaes" do
-            @selection[0..-2].each do |tag|
-              tag.name.should == 'a'
-            end
+        context 'when a sub navigation item is selected' do
+          before do
+            navigation[:invoices].stub(selected?: true)
+
+            navigation[:invoices]
+              .sub_navigation[:unpaid]
+              .stub(selected?: true, selected_by_condition?: true)
           end
-          it "should not render link for leaf" do
-            @selection.last.name.should == 'span'
+
+          it 'renders all items as links' do
+            expect(output).to have_css('div a', 2)
           end
-        end
-      end
 
+          context 'when the :static_leaf option is true' do
+            let(:options) {{ level: :all, static_leaf: true }}
 
-      context 'nested sub_navigation' do
-        it "should add an a tag for each selected item" do
-          HTML::Selector.new('div a').select(render(:subnav1)).should have(2).entries
+            it 'renders the items as links' do
+              expect(output).to have_css('div a')
+            end
+
+            it 'renders the last item as simple text' do
+              expect(output).to have_css('div span')
+            end
+          end
         end
       end
     end