refinerycms-pages 2.1.5 → 3.0.0

data/spec/helpers/refinery/pages/admin/pages_helper_spec.rb

@@ -2,29 +2,29 @@ require "spec_helper"
 
 module Refinery
   module Admin
-    describe PagesHelper do
+    describe PagesHelper, :type => :helper do
       describe "#template_options" do
         context "when page layout/view template is set" do
           it "returns those templates as selected" do
             page = FactoryGirl.create(:page)
 
             page.view_template = "rspec_template"
-            helper.template_options(:view_template, page).should eq(:selected => "rspec_template")
+            expect(helper.template_options(:view_template, page)).to eq(:selected => "rspec_template")
 
             page.layout_template = "rspec_layout"
-            helper.template_options(:layout_template, page).should eq(:selected => "rspec_layout")
+            expect(helper.template_options(:layout_template, page)).to eq(:selected => "rspec_layout")
           end
         end
 
         context "when page layout template is set using symbols" do
           before do
-            Pages.config.stub(:layout_template_whitelist).and_return [:three, :one, :two]
+            allow(Pages.config).to receive(:layout_template_whitelist).and_return [:three, :one, :two]
           end
 
           it "works as expected" do
             page = FactoryGirl.create(:page, :layout_template => "three")
 
-            helper.template_options(:layout_template, page).should eq(:selected => 'three')
+            expect(helper.template_options(:layout_template, page)).to eq(:selected => 'three')
           end
         end
 
@@ -35,7 +35,7 @@ module Refinery
               page = FactoryGirl.create(:page, :parent_id => parent.id)
 
               expected_layout = { :selected => parent.layout_template }
-              helper.template_options(:layout_template, page).should eq(expected_layout)
+              expect(helper.template_options(:layout_template, page)).to eq(expected_layout)
             end
           end
 
@@ -44,7 +44,7 @@ module Refinery
               page = FactoryGirl.create(:page)
 
               expected_layout = { :selected => "application" }
-              helper.template_options(:layout_template, page).should eq(expected_layout)
+              expect(helper.template_options(:layout_template, page)).to eq(expected_layout)
             end
           end
         end
@@ -57,7 +57,9 @@ module Refinery
           it "adds 'hidden' label" do
             page.show_in_menu = false
 
-            helper.page_meta_information(page).should eq(%q{<span class="label">hidden</span>})
+            expect(helper.page_meta_information(page)).to eq(
+              %Q{<span class="label">#{::I18n.t('refinery.admin.pages.page.hidden')}</span>}
+            )
           end
         end
 
@@ -65,7 +67,9 @@ module Refinery
           it "adds 'draft' label" do
             page.draft = true
 
-            helper.page_meta_information(page).should eq(%q{<span class="label notice">draft</span>})
+            expect(helper.page_meta_information(page)).to eq(
+              %Q{<span class="label notice">#{::I18n.t('refinery.admin.pages.page.draft')}</span>}
+            )
           end
         end
       end
@@ -87,14 +91,14 @@ module Refinery
 
         context "when title is present" do
           it "returns it" do
-            helper.page_title_with_translations(page).should eq("draft")
+            expect(helper.page_title_with_translations(page)).to eq("draft")
           end
         end
 
         context "when title for current locale isn't available" do
           it "returns existing title from translations" do
             Page.translation_class.where(:locale => :en).first.destroy
-            helper.page_title_with_translations(page).should eq("melnraksts")
+            expect(helper.page_title_with_translations(page)).to eq("melnraksts")
           end
         end
       end

data/spec/helpers/refinery/pages/content_pages_helper_spec.rb

@@ -2,28 +2,28 @@ require 'spec_helper'
 
 module Refinery
   module Pages
-    describe ContentPagesHelper do
+    describe ContentPagesHelper, :type => :helper do
       let(:content_presenter) { double(ContentPresenter, :hide_sections => nil, :fetch_template_overrides => nil, :to_html => nil) }
 
       describe "when rendering content presenter" do
         it "asks to content presenter to hide sections if told to" do
-          content_presenter.should_receive(:hide_sections).with(['foo', 'bar'])
+          expect(content_presenter).to receive(:hide_sections).with(['foo', 'bar'])
           render_content_presenter(content_presenter, :hide_sections => ['foo', 'bar'])
         end
 
         it "attempts to fetch template overrides declared elsewhere via content_for" do
-          content_presenter.should_receive(:fetch_template_overrides).and_yield(12)
-          self.should_receive(:content_for).with(12)
+          expect(content_presenter).to receive(:fetch_template_overrides).and_yield(12)
+          expect(self).to receive(:content_for).with(12)
           render_content_presenter(content_presenter)
         end
 
         it "outputs the html rendered by the content presenter" do
-          content_presenter.should_receive(:to_html).and_return('foobar')
-          render_content_presenter(content_presenter).should == 'foobar'
+          expect(content_presenter).to receive(:to_html).and_return('foobar')
+          expect(render_content_presenter(content_presenter)).to eq('foobar')
         end
 
         it "passes can_use_fallback option through to html rendering" do
-          content_presenter.should_receive(:to_html).with(true)
+          expect(content_presenter).to receive(:to_html).with(true)
           render_content_presenter(content_presenter, :can_use_fallback => true)
         end
       end
@@ -32,11 +32,11 @@ module Refinery
         let(:page) { double(Page) }
 
         it "builds a content page presenter and returns its html" do
-          self.should_receive(:page_title).and_return('some title')
-          Refinery::Pages::ContentPagePresenter.should_receive(:new).with(page, 'some title').and_return(content_presenter)
-          content_presenter.should_receive(:to_html).and_return('barfoo')
+          expect(self).to receive(:page_title).and_return('some title')
+          expect(Refinery::Pages::ContentPagePresenter).to receive(:new).with(page, 'some title').and_return(content_presenter)
+          expect(content_presenter).to receive(:to_html).and_return('barfoo')
 
-          render_content_page(page).should == 'barfoo'
+          expect(render_content_page(page)).to eq('barfoo')
         end
       end
     end

data/spec/lib/generators/refinery/pages/pages_generator_spec.rb

@@ -13,7 +13,7 @@ module Refinery
     end
 
     specify do
-      destination_root.should have_structure {
+      expect(destination_root).to have_structure {
         directory "config" do
           directory "initializers" do
             directory "refinery" do

data/spec/lib/pages_spec.rb

@@ -12,13 +12,13 @@ module Refinery
 
       context "when pattern match valid templates" do
         it "returns an array of valid templates" do
-          subject.valid_templates('spec', '*html*').should include("ugisozols")
+          expect(subject.valid_templates('spec', '*html*')).to include("ugisozols")
         end
       end
 
       context "when pattern doesn't match valid templates" do
         it "returns empty array" do
-          subject.valid_templates('huh', '*html*').should == []
+          expect(subject.valid_templates('huh', '*html*')).to eq([])
         end
       end
     end

data/spec/lib/refinery/pages/tab_spec.rb

@@ -14,7 +14,7 @@ module Refinery
           tab.partial = "rspec"
         end
 
-        Refinery::Pages.tabs.should include(rspec_tab)
+        expect(Refinery::Pages.tabs).to include(rspec_tab)
       end
     end
 
@@ -29,7 +29,7 @@ module Refinery
           tab.partial = "rspec"
         end
 
-        Refinery::Pages.tabs_for_template("huh").should include(rspec_tab)
+        expect(Refinery::Pages.tabs_for_template("huh")).to include(rspec_tab)
       end
 
       it "returns tabs with matched template" do
@@ -39,7 +39,7 @@ module Refinery
           tab.templates = "rspec"
         end
 
-        Refinery::Pages.tabs_for_template("rspec").should include(rspec_tab)
+        expect(Refinery::Pages.tabs_for_template("rspec")).to include(rspec_tab)
       end
     end
 
@@ -50,19 +50,19 @@ module Refinery
 
       describe ".register" do
         it "requires name to be set" do
-          lambda {
+          expect {
             Refinery::Pages::Tab.register do |tab|
               tab.partial = "rspec"
             end
-          }.should raise_error
+          }.to raise_error(ArgumentError)
         end
 
         it "requires partial to be set" do
-          lambda {
+          expect {
             Refinery::Pages::Tab.register do |tab|
               tab.name = "rspec"
             end
-          }.should raise_error
+          }.to raise_error(ArgumentError)
         end
 
         it "sets #templates if it's not set" do
@@ -71,7 +71,7 @@ module Refinery
             tab.partial = "rspec"
           end
 
-          rspec_tab.templates.should eq(["all"])
+          expect(rspec_tab.templates).to eq(["all"])
         end
 
         it "converts #templates to array if it's not an array already" do
@@ -81,7 +81,7 @@ module Refinery
             tab.templates = "rspec"
           end
 
-          rspec_tab.templates.should eq(["rspec"])
+          expect(rspec_tab.templates).to eq(["rspec"])
         end
       end
     end

data/spec/lib/refinery/pages/url_spec.rb

@@ -6,7 +6,7 @@ module Refinery
       describe ".handle?" do
         it "returns true if link_url is present" do
           page = double(:page, :link_url => "/")
-          Url::Localised.handle?(page).should be_true
+          expect(Url::Localised.handle?(page)).to be_truthy
         end
       end
 
@@ -15,17 +15,17 @@ module Refinery
 
         context "when current frontend locale != default frontend locale" do
           it "returns link_url prefixed with current frontend locale" do
-            Refinery::I18n.stub(:current_frontend_locale).and_return(:lv)
-            Refinery::I18n.stub(:default_frontend_locale).and_return(:en)
-            Url::Localised.new(page).url.should eq("/lv/test")
+            allow(Refinery::I18n).to receive(:current_frontend_locale).and_return(:lv)
+            allow(Refinery::I18n).to receive(:default_frontend_locale).and_return(:en)
+            expect(Url::Localised.new(page).url).to eq("/lv/test")
           end
         end
 
         context "when current frontend locale == default frontend locale" do
           it "returns unaltered link_url" do
-            Refinery::I18n.stub(:current_frontend_locale).and_return(:en)
-            Refinery::I18n.stub(:default_frontend_locale).and_return(:en)
-            Url::Localised.new(page).url.should eq("/test")
+            allow(Refinery::I18n).to receive(:current_frontend_locale).and_return(:en)
+            allow(Refinery::I18n).to receive(:default_frontend_locale).and_return(:en)
+            expect(Url::Localised.new(page).url).to eq("/test")
           end
         end
       end
@@ -35,15 +35,15 @@ module Refinery
       describe ".handle?" do
         it "returns true if marketable_url config is set to true" do
           page = double(:page)
-          Refinery::Pages.stub(:marketable_url).and_return(true)
-          Url::Marketable.handle?(page).should be_true
+          allow(Refinery::Pages).to receive(:marketable_url).and_return(true)
+          expect(Url::Marketable.handle?(page)).to be_truthy
         end
       end
 
       describe "#url" do
         it "returns hash" do
           page = double(:page, :nested_url => "test")
-          Url::Marketable.new(page).url.should eq({
+          expect(Url::Marketable.new(page).url).to eq({
             :controller => "/refinery/pages", :action => "show", :only_path => true,
             :path => "test", :id => nil
           })
@@ -55,14 +55,14 @@ module Refinery
       describe ".handle?" do
         it "returns true if to_param is present" do
           page = double(:page, :to_param => "test")
-          Url::Normal.handle?(page).should be_true
+          expect(Url::Normal.handle?(page)).to be_truthy
         end
       end
 
       describe "#url" do
         it "returns hash" do
           page = double(:page, :to_param => "test")
-          Url::Normal.new(page).url.should eq({
+          expect(Url::Normal.new(page).url).to eq({
             :controller => "/refinery/pages", :action => "show", :only_path => true,
             :path => nil, :id => "test"
           })

data/spec/models/refinery/page_finder_spec.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+require 'spec_helper'
+
+module Refinery
+  describe Page do
+    let(:page_title) { 'RSpec is great for testing too' }
+    let(:child_title) { 'The child page' }
+
+    let(:created_page) { subject.class.create!(:title => page_title, :deletable => true) }
+    let(:created_child) { created_page.children.create!(:title => child_title) }
+
+    describe '.find_by_path' do
+      let(:page_title)  { 'team' }
+      let(:child_title) { 'about' }
+      let(:created_root_about) { subject.class.create!(:title => child_title, :deletable => true) }
+
+      before do
+        # Ensure pages are created.
+        created_child
+        created_root_about
+      end
+
+      it "should return (root) about page when looking for '/about'" do
+        expect(Page.find_by_path('/about')).to eq(created_root_about)
+      end
+
+      it "should return child about page when looking for '/team/about'" do
+        expect(Page.find_by_path('/team/about')).to eq(created_child)
+      end
+    end
+
+    describe ".find_by_path_or_id" do
+      let!(:market) { FactoryGirl.create(:page, :title => "market") }
+      let(:path) { "market" }
+      let(:id) { market.id }
+
+      context "when path param is present" do
+        context "when path is friendly_id" do
+          it "finds page using path" do
+            expect(Page.find_by_path_or_id(path, "")).to eq(market)
+          end
+        end
+
+        context "when path is not friendly_id" do
+          it "finds page using id" do
+            expect(Page.find_by_path_or_id(id, "")).to eq(market)
+          end
+        end
+      end
+
+      context "when id param is present" do
+        it "finds page using id" do
+          expect(Page.find_by_path_or_id("", id)).to eq(market)
+        end
+      end
+    end
+
+    describe ".find_by_path_or_id!" do
+      it "delegates to find_by_path_or_id" do
+        lambda do
+          expect(Page).to receive(:find_by_path_or_id).with("path", "id")
+          Page.find_by_path_or_id!("path", "id")
+        end
+      end
+
+      it "throws exception when page isn't found" do
+        expect { Page.find_by_path_or_id!("not", "here") }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+  end
+end

data/spec/models/refinery/page_menu_spec.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+require 'spec_helper'
+
+module Refinery
+  describe Page do
+    let(:page_title) { 'RSpec is great for testing too' }
+    let(:page) { subject.class.new(:title => page_title, :deletable => true)}
+
+    describe "#to_refinery_menu_item" do
+      let(:page) do
+        Page.new(
+          :id => 5,
+          :parent_id => 8,
+          :menu_match => "^/foo$"
+
+        # Page does not allow setting lft and rgt, so stub them.
+        ).tap do |p|
+          p[:lft] = 6
+          p[:rgt] = 7
+        end
+      end
+
+      subject { page.to_refinery_menu_item }
+
+      shared_examples_for("Refinery menu item hash") do
+        [ [:id, 5],
+          [:lft, 6],
+          [:rgt, 7],
+          [:parent_id, 8],
+          [:menu_match, "^/foo$"]
+        ].each do |attr, value|
+          it "returns the correct :#{attr}" do
+            expect(subject[attr]).to eq(value)
+          end
+        end
+
+        it "returns the correct :url" do
+          expect(subject[:url]).to be_a(Hash) # guard against nil
+          expect(subject[:url]).to eq(page.url)
+        end
+      end
+
+      context "with #menu_title" do
+        before do
+          page[:menu_title] = "Menu Title"
+        end
+
+        it_should_behave_like "Refinery menu item hash"
+
+        it "returns the menu_title for :title" do
+          expect(subject[:title]).to eq("Menu Title")
+        end
+      end
+
+      context "with #title" do
+        before do
+          page[:title] = "Title"
+        end
+
+        it_should_behave_like "Refinery menu item hash"
+
+        it "returns the title for :title" do
+          expect(subject[:title]).to eq("Title")
+        end
+      end
+    end
+
+    describe "#in_menu?" do
+      context "when live? and show_in_menu? returns true" do
+        it "returns true" do
+          allow(page).to receive(:live?).and_return(true)
+          allow(page).to receive(:show_in_menu?).and_return(true)
+          expect(page.in_menu?).to be_truthy
+        end
+      end
+
+      context "when live? or show_in_menu? doesn't return true" do
+        it "returns false" do
+          allow(page).to receive(:live?).and_return(true)
+          allow(page).to receive(:show_in_menu?).and_return(false)
+          expect(page.in_menu?).to be_falsey
+
+          allow(page).to receive(:live?).and_return(false)
+          allow(page).to receive(:show_in_menu?).and_return(true)
+          expect(page.in_menu?).to be_falsey
+        end
+      end
+    end
+
+    describe "#not_in_menu?" do
+      context "when in_menu? returns true" do
+        it "returns false" do
+          allow(page).to receive(:in_menu?).and_return(true)
+          expect(page.not_in_menu?).to be_falsey
+        end
+      end
+
+      context "when in_menu? returns false" do
+        it "returns true" do
+          allow(page).to receive(:in_menu?).and_return(false)
+          expect(page.not_in_menu?).to be_truthy
+        end
+      end
+    end
+
+  end
+end