alchemy_cms 2.9.1 → 3.0.0.rc5

data/spec/models/message_spec.rb

@@ -11,17 +11,22 @@ module Alchemy
       end
     end
 
-    describe '#persisted?' do
-      it "should return false" do
-        expect(message.persisted?).to eq(false)
+    it "has attributes writers and getters for all fields defined in mailer config" do
+      Config.get(:mailer)['fields'].each do |field|
+        expect(message).to respond_to(field)
+        expect(message).to respond_to("#{field}=")
       end
     end
 
-    describe '#attributes' do
-      it "should call .attributes" do
-        Message.should_receive(:attributes)
-        message.attributes
+    it "validates attributes defined in mailer config" do
+      Config.get(:mailer)['validate_fields'].each do |field|
+        expect(message).to have(1).error_on(field)
       end
     end
+
+    it "validates email format" do
+      message.email = 'wrong email format'
+      expect(message.errors_on(:email)).to include("is invalid")
+    end
   end
 end

data/spec/models/page_spec.rb

@@ -6,10 +6,10 @@ module Alchemy
   describe Page do
 
     let(:rootpage)      { Page.root }
-    let(:language)      { Language.get_default }
+    let(:language)      { Language.default }
     let(:klingonian)    { FactoryGirl.create(:klingonian) }
     let(:language_root) { FactoryGirl.create(:language_root_page) }
-    let(:page)          { mock(:page, :page_layout => 'foo') }
+    let(:page)          { mock_model(Page, :page_layout => 'foo') }
     let(:public_page)   { FactoryGirl.create(:public_page) }
     let(:news_page)     { FactoryGirl.create(:public_page, :page_layout => 'news', :do_not_autogenerate => false) }
 
@@ -18,12 +18,15 @@ module Alchemy
 
     context 'validations' do
       context "Creating a normal content page" do
-        let(:contentpage) { FactoryGirl.build(:page) }
+        let(:contentpage)              { FactoryGirl.build(:page) }
+        let(:with_same_urlname)        { FactoryGirl.create(:page, urlname: "existing_twice") }
+        let(:global_with_same_urlname) { FactoryGirl.create(:page, urlname: "existing_twice", layoutpage: true) }
 
         context "when its urlname exists as global page" do
+          before { global_with_same_urlname }
+
           it "it should be possible to save." do
             contentpage.urlname = "existing_twice"
-            global_with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice", :layoutpage => true)
             contentpage.should be_valid
           end
         end
@@ -40,25 +43,30 @@ module Alchemy
           contentpage.should have(1).error_on(:parent_id)
         end
 
-        it "should validate the uniqueness of urlname" do
-          with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
-          contentpage.urlname = 'existing_twice'
-          contentpage.should_not be_valid
+        context 'with page having same urlname' do
+          before { with_same_urlname }
+
+          it "should not be valid" do
+            contentpage.urlname = 'existing_twice'
+            contentpage.should_not be_valid
+          end
         end
 
         context "with url_nesting set to true" do
-          before { Config.stub!(:get).and_return(true) }
+          let(:other_parent) { FactoryGirl.create(:page, parent_id: Page.root.id) }
+
+          before do
+            Config.stub(:get).and_return(true)
+            with_same_urlname
+          end
 
           it "should only validate urlname dependent of parent" do
-            other_parent = FactoryGirl.create(:page, parent_id: Page.root.id)
-            with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
             contentpage.urlname = 'existing_twice'
             contentpage.parent_id = other_parent.id
             contentpage.should be_valid
           end
 
           it "should validate urlname dependent of parent" do
-            with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
             contentpage.urlname = 'existing_twice'
             contentpage.should_not be_valid
           end
@@ -170,18 +178,18 @@ module Alchemy
 
         context "with cells" do
           before do
-            @page.stub!(:definition).and_return({'name' => 'with_cells', 'cells' => ['header', 'main']})
+            @page.stub(:definition).and_return({'name' => 'with_cells', 'cells' => ['header', 'main']})
           end
 
           it "should have the generated elements in their cells" do
-            @page.stub!(:cell_definitions).and_return([{'name' => 'header', 'elements' => ['article']}])
+            @page.stub(:cell_definitions).and_return([{'name' => 'header', 'elements' => ['article']}])
             @page.save
             @page.cells.where(:name => 'header').first.elements.should_not be_empty
           end
 
           context "and no elements in cell definitions" do
             it "should have the elements in the nil cell" do
-              @page.stub!(:cell_definitions).and_return([{'name' => 'header', 'elements' => []}])
+              @page.stub(:cell_definitions).and_return([{'name' => 'header', 'elements' => []}])
               @page.save
               @page.cells.collect(&:elements).flatten.should be_empty
             end
@@ -242,17 +250,19 @@ module Alchemy
       end
 
       context "after changing the page layout" do
-        let(:news_element) { FactoryGirl.create(:element, :name => 'news') }
+        let(:news_element) { news_page.elements.find_by(name: 'news') }
 
         it "all elements not allowed on this page should be trashed" do
-          news_page.elements << news_element
-          news_page.update_attributes :page_layout => 'standard'
-          news_page.elements.trashed.should include(news_element)
+          expect(news_page.elements.trashed).to be_empty
+          news_page.update_attributes(page_layout: 'standard')
+          trashed = news_page.elements.trashed.pluck(:name)
+          expect(trashed).to eq(['news'])
+          expect(trashed).to_not include('article', 'header')
         end
 
         it "should autogenerate elements" do
-          news_page.update_attributes :page_layout => 'standard'
-          news_page.elements.available.collect(&:name).should include('header')
+          news_page.update_attributes(page_layout: 'contact')
+          news_page.elements.pluck(:name).should include('contactform')
         end
       end
     end
@@ -376,7 +386,7 @@ module Alchemy
       context "page with autogenerate elements" do
         before do
           page = FactoryGirl.create(:page)
-          page.stub!(:definition).and_return({'name' => 'standard', 'elements' => ['headline'], 'autogenerate' => ['headline']})
+          page.stub(:definition).and_return({'name' => 'standard', 'elements' => ['headline'], 'autogenerate' => ['headline']})
         end
 
         it "the copy should not autogenerate elements" do
@@ -404,6 +414,13 @@ module Alchemy
           page.urlname.should == 'klingon-stoessel'
         end
 
+        context "with no name set" do
+          it "should not set a urlname" do
+            page = Page.create(name: '', language: language, parent_id: language_root.id)
+            expect(page.urlname).to be_blank
+          end
+        end
+
         it "should generate a three letter urlname from two letter name" do
           page = FactoryGirl.create(:page, :name => 'Au', :language => language, :parent_id => language_root.id)
           page.urlname.should == '-au'
@@ -421,7 +438,52 @@ module Alchemy
 
         it "should add a user stamper" do
           page = FactoryGirl.create(:page, :name => 'A', :language => language, :parent_id => language_root.id)
-          page.class.stamper_class.to_s.should == 'User'
+          page.class.stamper_class.to_s.should == 'DummyUser'
+        end
+
+        context "with language given" do
+          it "does not set the language from parent" do
+            Page.any_instance.should_not_receive(:set_language_from_parent_or_default)
+            Page.create!(name: 'A', parent_id: language_root.id, page_layout: 'standard', language: language)
+          end
+        end
+
+        context "with no language given" do
+          it "sets the language from parent" do
+            Page.any_instance.should_receive(:set_language_from_parent_or_default)
+            Page.create!(name: 'A', parent_id: language_root.id, page_layout: 'standard')
+          end
+        end
+      end
+    end
+
+    describe '.find_or_create_layout_root_for' do
+      subject { Page.find_or_create_layout_root_for(language_id) }
+
+      let(:language)    { mock_model('Language', name: 'English') }
+      let(:language_id) { language.id }
+
+      before { Language.stub(:find).and_return(language) }
+
+      context 'if no layout root page for given language id could be found' do
+        before do
+          Page.should_receive(:create!).and_return(page)
+        end
+
+        it "creates one" do
+          should eq(page)
+        end
+      end
+
+      context 'if layout root page for given language id could be found' do
+        let(:page) { mock_model('Page') }
+
+        before do
+          Page.should_receive(:layout_root_for).and_return(page)
+        end
+
+        it "returns layout root page" do
+          should eq(page)
         end
       end
     end
@@ -591,9 +653,9 @@ module Alchemy
     describe '#cell_definitions' do
       before do
         @page = FactoryGirl.build(:page, :page_layout => 'foo')
-        @page.stub!(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"]})
+        @page.stub(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"]})
         @cell_descriptions = [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
-        Cell.stub!(:definitions).and_return(@cell_descriptions)
+        Cell.stub(:definitions).and_return(@cell_descriptions)
       end
 
       it "should return all cell definitions for its page_layout" do
@@ -601,21 +663,30 @@ module Alchemy
       end
 
       it "should return empty array if no cells defined in page layout" do
-        @page.stub!(:layout_description).and_return({'name' => "foo"})
+        @page.stub(:layout_description).and_return({'name' => "foo"})
         @page.cell_definitions.should == []
       end
     end
 
     describe '#destroy' do
       context "with trashed but still assigned elements" do
-
         before { news_page.elements.map(&:trash!) }
 
         it "should not delete the trashed elements" do
           news_page.destroy
           Element.trashed.should_not be_empty
         end
+      end
+    end
 
+    describe '#element_definitions' do
+      let(:page) { FactoryGirl.build_stubbed(:page) }
+      subject { page.element_definitions }
+      before { Element.should_receive(:definitions).and_return([{'name' => 'article'}, {'name' => 'header'}]) }
+
+      it "returns all element definitions that could be placed on current page" do
+        should include({'name' => 'article'})
+        should include({'name' => 'header'})
       end
     end
 
@@ -677,7 +748,7 @@ module Alchemy
           'elements' => ['header', 'text'],
           'autogenerate' => ['header', 'text']
         })
-        Cell.stub!(:definitions).and_return([{
+        Cell.stub(:definitions).and_return([{
           'name' => "header",
           'elements' => ["header"]
         }])
@@ -697,7 +768,7 @@ module Alchemy
     describe '#feed_elements' do
       it "should return all rss feed elements" do
         news_page.feed_elements.should_not be_empty
-        news_page.feed_elements.should == Element.find_all_by_name('news')
+        news_page.feed_elements.should == Element.where(name: 'news').to_a
       end
     end
 
@@ -709,23 +780,23 @@ module Alchemy
 
       context "with show_non_public argument TRUE" do
         it "should return all elements from empty options" do
-          public_page.find_elements({}, true).all.should == public_page.elements.all
+          public_page.find_elements({}, true).to_a.should == public_page.elements.to_a
         end
 
         it "should only return the elements passed as options[:only]" do
-          public_page.find_elements({:only => ['article']}, true).all.should == public_page.elements.named('article').all
+          public_page.find_elements({:only => ['article']}, true).to_a.should == public_page.elements.named('article').to_a
         end
 
         it "should not return the elements passed as options[:except]" do
-          public_page.find_elements({:except => ['article']}, true).all.should == public_page.elements - public_page.elements.named('article').all
+          public_page.find_elements({:except => ['article']}, true).to_a.should == public_page.elements - public_page.elements.named('article').to_a
         end
 
         it "should return elements offsetted" do
-          public_page.find_elements({:offset => 2}, true).all.should == public_page.elements.offset(2)
+          public_page.find_elements({:offset => 2}, true).to_a.should == public_page.elements.offset(2)
         end
 
         it "should return elements limitted in count" do
-          public_page.find_elements({:count => 1}, true).all.should == public_page.elements.limit(1)
+          public_page.find_elements({:count => 1}, true).to_a.should == public_page.elements.limit(1)
         end
       end
 
@@ -750,7 +821,7 @@ module Alchemy
             }
 
             it "returns empty set" do
-              public_page.elements.should_receive(:where).with('1 = 0').and_return(elements)
+              Element.should_receive(:none).and_return(elements)
               public_page.find_elements(from_cell: 'Lolo').to_a.should == []
             end
 
@@ -773,23 +844,23 @@ module Alchemy
 
       context "with show_non_public argument FALSE" do
         it "should return all elements from empty arguments" do
-          public_page.find_elements().all.should == public_page.elements.published.all
+          public_page.find_elements().to_a.should == public_page.elements.published.to_a
         end
 
         it "should only return the public elements passed as options[:only]" do
-          public_page.find_elements(:only => ['article']).all.should == public_page.elements.published.named('article').all
+          public_page.find_elements(:only => ['article']).to_a.should == public_page.elements.published.named('article').to_a
         end
 
         it "should return all public elements except the ones passed as options[:except]" do
-          public_page.find_elements(:except => ['article']).all.should == public_page.elements.published.all - public_page.elements.published.named('article').all
+          public_page.find_elements(:except => ['article']).to_a.should == public_page.elements.published.to_a - public_page.elements.published.named('article').to_a
         end
 
         it "should return elements offsetted" do
-          public_page.find_elements({:offset => 2}).all.should == public_page.elements.published.offset(2)
+          public_page.find_elements({:offset => 2}).to_a.should == public_page.elements.published.offset(2)
         end
 
         it "should return elements limitted in count" do
-          public_page.find_elements({:count => 1}).all.should == public_page.elements.published.limit(1)
+          public_page.find_elements({:count => 1}).to_a.should == public_page.elements.published.limit(1)
         end
       end
     end
@@ -810,7 +881,7 @@ module Alchemy
     end
 
     context 'folding' do
-      let(:user) { mock_model('User') }
+      let(:user) { mock_model('DummyUser') }
 
       describe '#fold!' do
         context "with folded status set to true" do
@@ -848,12 +919,20 @@ module Alchemy
       end
     end
 
-    describe '#lock!' do
-      let(:page) { FactoryGirl.create(:page) }
-      let(:user) { mock_model('User') }
+    describe '#get_language_root' do
+      subject { public_page.get_language_root }
+
+      it "returns the language root page" do
+        should eq language_root
+      end
+    end
+
+    describe '#lock_to!' do
+      let(:page) { create(:page) }
+      let(:user) { mock_model('DummyUser') }
 
       it "should set locked to true" do
-        page.lock!(user)
+        page.lock_to!(user)
         page.reload
         page.locked.should == true
       end
@@ -863,19 +942,19 @@ module Alchemy
       end
 
       it "should set locked_by to the users id" do
-        page.lock!(user)
+        page.lock_to!(user)
         page.reload
         page.locked_by.should == user.id
       end
     end
 
-    describe '#paste_from_clipboard' do
+    describe '#copy_and_paste' do
       let(:source) { FactoryGirl.build_stubbed(:page) }
       let(:new_parent) { FactoryGirl.build_stubbed(:page) }
       let(:page_name) { "Pagename (pasted)" }
       let(:copied_page) { mock_model('Page') }
 
-      subject { Page.paste_from_clipboard(source, new_parent, page_name) }
+      subject { Page.copy_and_paste(source, new_parent, page_name) }
 
       it "should copy the source page with the given name to the new parent" do
         Page.should_receive(:copy).with(source, {
@@ -888,14 +967,14 @@ module Alchemy
       end
 
       it "should return the copied page" do
-        Page.stub!(:copy).and_return(copied_page)
+        Page.stub(:copy).and_return(copied_page)
         expect(subject).to be_a(copied_page.class)
       end
 
       context "if source page has children" do
         it "should also copy and paste the children" do
-          Page.stub!(:copy).and_return(copied_page)
-          source.stub!(:children).and_return([mock_model('Page')])
+          Page.stub(:copy).and_return(copied_page)
+          source.stub(:children).and_return([mock_model('Page')])
           source.should_receive(:copy_children_to).with(copied_page)
           subject
         end
@@ -971,22 +1050,28 @@ module Alchemy
 
     describe '#publish!' do
       let(:page) { FactoryGirl.build_stubbed(:page, public: false) }
+      let(:current_time) { Time.now }
 
       before do
-        page.stub!(:save).and_return(true)
+        current_time
+        Time.stub(:now).and_return(current_time)
         page.publish!
       end
 
       it "sets public attribute to true" do
         page.public.should == true
       end
+
+      it "sets published_at attribute to current time" do
+        page.published_at.should == current_time
+      end
     end
 
-    describe '#set_language_from_parent_or_default_language' do
+    describe '#set_language_from_parent_or_default' do
       let(:default_language) { mock_model('Language', code: 'es') }
       let(:page) { Page.new }
 
-      before { page.stub!(:parent).and_return(parent) }
+      before { page.stub(:parent).and_return(parent) }
 
       subject { page }
 
@@ -994,23 +1079,21 @@ module Alchemy
         let(:parent) { mock_model('Page', language: default_language, language_id: default_language.id, language_code: default_language.code) }
 
         before do
-          page.set_language_from_parent_or_default_language
+          page.send(:set_language_from_parent_or_default)
         end
 
         its(:language_id) { should eq(parent.language_id) }
-        its(:language_code) { should eq(parent.language_code) }
       end
 
       context "parent has no language" do
         let(:parent) { mock_model('Page', language: nil, language_id: nil, language_code: nil) }
 
         before do
-          Language.stub!(:get_default).and_return(default_language)
-          page.set_language_from_parent_or_default_language
+          Language.stub(:default).and_return(default_language)
+          page.send(:set_language_from_parent_or_default)
         end
 
         its(:language_id) { should eq(default_language.id) }
-        its(:language_code) { should eq(default_language.code) }
       end
     end
 
@@ -1043,7 +1126,11 @@ module Alchemy
     describe '#unlock!' do
       let(:page) { FactoryGirl.create(:page, locked: true, locked_by: 1) }
 
-      its "should set the locked status to false" do
+      before do
+        page.stub(:save).and_return(true)
+      end
+
+      it "should set the locked status to false" do
         page.unlock!
         page.reload
         page.locked.should == false
@@ -1058,6 +1145,12 @@ module Alchemy
         page.reload
         page.locked_by.should == nil
       end
+
+      it "sets current preview to nil" do
+        Page.current_preview = page
+        page.unlock!
+        Page.current_preview.should be_nil
+      end
     end
 
     context 'urlname updating' do
@@ -1068,7 +1161,7 @@ module Alchemy
       let(:contact)      { FactoryGirl.create(:page, parent_id: invisible.id, name: 'contact', visible: true) }
 
       context "with activated url_nesting" do
-        before { Config.stub!(:get).and_return(true) }
+        before { Config.stub(:get).and_return(true) }
 
         it "should store all parents urlnames delimited by slash" do
           page.urlname.should == 'parentparent/parent/page'
@@ -1096,10 +1189,10 @@ module Alchemy
           end
 
           it "should create a legacy url" do
-            page.stub!(:slug).and_return('foo')
+            page.stub(:slug).and_return('foo')
             page.update_urlname!
             page.legacy_urls.should_not be_empty
-            page.legacy_urls.collect(&:urlname).should include('parentparent/parent/page')
+            page.legacy_urls.pluck(:urlname).should include('parentparent/parent/page')
           end
         end
 
@@ -1115,7 +1208,7 @@ module Alchemy
       end
 
       context "with disabled url_nesting" do
-        before { Config.stub!(:get).and_return(false) }
+        before { Config.stub(:get).and_return(false) }
 
         it "should only store my urlname" do
           page.urlname.should == 'page'
@@ -1123,124 +1216,6 @@ module Alchemy
       end
     end
 
-    describe "#update_node!" do
-
-      let(:original_url) { "sample-url" }
-      let(:page) { FactoryGirl.create(:page, :language => language, :parent_id => language_root.id, :urlname => original_url, restricted: false) }
-      let(:node) { TreeNode.new(10, 11, 12, 13, "another-url", true) }
-
-      context "when nesting is enabled" do
-        before { Alchemy::Config.stub(:get).with(:url_nesting) { true } }
-
-        context "when page is not external" do
-
-          before { page.stub(redirects_to_external?: false)}
-
-          it "should update all attributes" do
-            page.update_node!(node)
-            page.reload
-            expect(page.lft).to eq(node.left)
-            expect(page.rgt).to eq(node.right)
-            expect(page.parent_id).to eq(node.parent)
-            expect(page.depth).to eq(node.depth)
-            expect(page.urlname).to eq(node.url)
-            expect(page.restricted).to eq(node.restricted)
-          end
-
-          context "when url is the same" do
-            let(:node) { TreeNode.new(10, 11, 12, 13, original_url, true) }
-
-            it "should not create a legacy url" do
-              page.update_node!(node)
-              page.reload
-              expect(page.legacy_urls.size).to eq(0)
-            end
-          end
-
-          context "when url is not the same" do
-            it "should create a legacy url" do
-              page.update_node!(node)
-              page.reload
-              expect(page.legacy_urls.size).to eq(1)
-            end
-          end
-        end
-
-        context "when page is external" do
-
-          before { page.stub(redirects_to_external?: true) }
-
-          it "should update all attributes except url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.lft).to eq(node.left)
-            expect(page.rgt).to eq(node.right)
-            expect(page.parent_id).to eq(node.parent)
-            expect(page.depth).to eq(node.depth)
-            expect(page.urlname).to eq(original_url)
-            expect(page.restricted).to eq(node.restricted)
-          end
-
-          it "should not create a legacy url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.legacy_urls.size).to eq(0)
-          end
-        end
-      end
-
-      context "when nesting is disabled" do
-        before { Alchemy::Config.stub(:get).with(:url_nesting) { false } }
-
-        context "when page is not external" do
-
-          before { page.stub(redirects_to_external?: false)}
-
-          it "should update all attributes except url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.lft).to eq(node.left)
-            expect(page.rgt).to eq(node.right)
-            expect(page.parent_id).to eq(node.parent)
-            expect(page.depth).to eq(node.depth)
-            expect(page.urlname).to eq(original_url)
-            expect(page.restricted).to eq(node.restricted)
-          end
-
-          it "should not create a legacy url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.legacy_urls.size).to eq(0)
-          end
-
-        end
-
-        context "when page is external" do
-
-          before { page.stub(redirects_to_external?: true) }
-
-          before { Alchemy::Config.stub(get: true) }
-
-          it "should update all attributes except url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.lft).to eq(node.left)
-            expect(page.rgt).to eq(node.right)
-            expect(page.parent_id).to eq(node.parent)
-            expect(page.depth).to eq(node.depth)
-            expect(page.urlname).to eq(original_url)
-            expect(page.restricted).to eq(node.restricted)
-          end
-
-          it "should not create a legacy url" do
-            page.update_node!(node)
-            page.reload
-            expect(page.legacy_urls.size).to eq(0)
-          end
-        end
-      end
-    end
-
     describe '#slug' do
       context "with parents path saved in urlname" do
         let(:page) { FactoryGirl.build(:page, urlname: 'root/parent/my-name')}
@@ -1299,7 +1274,7 @@ module Alchemy
       let(:page) { Page.new }
 
       context 'with user class having a name accessor' do
-        let(:user) { Alchemy.user_class_name = double(name: 'Paul Page') }
+        let(:user) { double(name: 'Paul Page') }
 
         describe '#creator_name' do
           before { page.stub(:creator).and_return(user) }
@@ -1360,8 +1335,8 @@ module Alchemy
 
       context 'if the page has a custom controller defined in its description' do
         before do
-          page.stub!(:has_controller?).and_return(true)
-          page.stub!(:layout_description).and_return({'controller' => 'comments', 'action' => 'index'})
+          page.stub(:has_controller?).and_return(true)
+          page.stub(:layout_description).and_return({'controller' => 'comments', 'action' => 'index'})
         end
         it "should return a Hash with controller and action key-value pairs" do
           expect(page.controller_and_action).to eq({controller: '/comments', action: 'index'})
@@ -1369,5 +1344,37 @@ module Alchemy
       end
     end
 
+    it_behaves_like "having a hint" do
+      let(:subject) { Page.new }
+    end
+
+    describe '#layout_partial_name' do
+      let(:page) { Page.new(page_layout: 'Standard Page') }
+
+      it "returns a partial renderer compatible name" do
+        expect(page.layout_partial_name).to eq('standard_page')
+      end
+    end
+
+    describe '#published_at' do
+      context 'with published_at date set' do
+        let(:published_at) { Time.now }
+        let(:page)         { build_stubbed(:page, published_at: published_at) }
+
+        it "returns the published_at value from database" do
+          expect(page.published_at).to eq(published_at)
+        end
+      end
+
+      context 'with published_at is nil' do
+        let(:updated_at) { Time.now }
+        let(:page)       { build_stubbed(:page, published_at: nil, updated_at: updated_at) }
+
+        it "returns the updated_at value" do
+          expect(page.published_at).to eq(updated_at)
+        end
+      end
+    end
+
   end
 end