trusty-cms 7.1.2 → 7.1.3

data/spec/models/page_part_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe PagePart do
+  describe 'validations' do
+    it 'requires a name' do
+      part = PagePart.new(content: 'body content')
+      expect(part).not_to be_valid
+      expect(part.errors[:name]).to be_present
+    end
+
+    it 'rejects a name longer than 100 characters' do
+      part = PagePart.new(name: 'a' * 101)
+      expect(part).not_to be_valid
+      expect(part.errors[:name]).to be_present
+    end
+
+    it 'rejects a filter_id longer than 25 characters' do
+      part = PagePart.new(name: 'body', filter_id: 'a' * 26)
+      expect(part).not_to be_valid
+      expect(part.errors[:filter_id]).to be_present
+    end
+
+    it 'is valid with a name' do
+      expect(PagePart.new(name: 'body')).to be_valid
+    end
+  end
+
+  describe 'ordering' do
+    it 'orders by name via the default scope' do
+      expect(PagePart.all.to_sql).to match(/ORDER BY name/i)
+    end
+  end
+end

data/spec/models/page_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe Page do
+  let(:home) { FactoryBot.create(:home, title: 'Home') }
+
+  describe 'paths' do
+    it 'renders the root path as "/"' do
+      expect(home.path).to eq('/')
+    end
+
+    it 'builds a child path from the parent path and slug' do
+      parent = FactoryBot.create(:page, title: 'Parent', slug: 'parent', parent: home, status_id: Status[:published].id)
+      expect(parent.path).to eq('/parent')
+    end
+
+    it 'builds a nested path across multiple ancestors' do
+      parent = FactoryBot.create(:page, title: 'Parent', slug: 'parent', parent: home, status_id: Status[:published].id)
+      child  = FactoryBot.create(:page, title: 'Child', slug: 'child', parent: parent, status_id: Status[:published].id)
+      expect(child.path).to eq('/parent/child')
+    end
+
+    it 'returns an empty string when the slug is blank' do
+      expect(FactoryBot.build(:page, slug: '').path).to eq('')
+    end
+
+    it '#child_path joins the page path with the child slug' do
+      parent = FactoryBot.create(:page, title: 'Parent', slug: 'parent', parent: home, status_id: Status[:published].id)
+      expect(home.child_path(parent)).to eq('/parent')
+    end
+
+    it 'aliases #url to #path' do
+      expect(home.url).to eq(home.path)
+    end
+  end
+
+  describe 'status' do
+    it '#status returns the Status for the status_id' do
+      expect(home.status).to eq(Status[:published])
+      expect(home.status.name).to eq('Published')
+    end
+
+    it '#status= assigns the status_id from a Status' do
+      page = FactoryBot.build(:page)
+      page.status = Status[:hidden]
+      expect(page.status_id).to eq(Status[:hidden].id)
+    end
+
+    it '#published? is true only for published pages' do
+      draft = FactoryBot.create(:page, title: 'Draft', slug: 'draft', parent: home, status_id: Status[:draft].id)
+      expect(home.published?).to be(true)
+      expect(draft.published?).to be(false)
+    end
+
+    it '#hidden? is true only for hidden pages' do
+      # Built (not created) to avoid the handle_hidden_status save callback,
+      # which references an unset config method in this environment.
+      hidden = FactoryBot.build(:page, title: 'Hidden', slug: 'hidden', parent: home, status_id: Status[:hidden].id)
+      expect(hidden.hidden?).to be(true)
+      expect(home.hidden?).to be(false)
+    end
+
+    it '#scheduled? is true only for scheduled pages' do
+      scheduled = FactoryBot.create(:page, title: 'Sched', slug: 'sched', parent: home, status_id: Status[:scheduled].id)
+      expect(scheduled.scheduled?).to be(true)
+      expect(home.scheduled?).to be(false)
+    end
+
+    it 'stamps published_at when a page is published' do
+      page = FactoryBot.create(:page, title: 'Pub', slug: 'pub', parent: home, status_id: Status[:published].id)
+      expect(page.published_at).to be_present
+    end
+
+    it 'does not stamp published_at for an unpublished page' do
+      draft = FactoryBot.create(:page, title: 'Draft2', slug: 'draft2', parent: home, status_id: Status[:draft].id)
+      expect(draft.published_at).to be_nil
+    end
+  end
+
+  describe 'parts' do
+    it '#part returns the named part' do
+      home.parts.create(name: 'body', content: 'x')
+      expect(home.part('body').content).to eq('x')
+    end
+
+    it '#part? reflects whether the part exists' do
+      home.parts.create(name: 'body', content: 'x')
+      expect(home.part?('body')).to be(true)
+      expect(home.part?('sidebar')).to be(false)
+    end
+
+    it '#inherits_part? is true when an ancestor has the part but the page does not' do
+      home.parts.create(name: 'body', content: 'x')
+      child = FactoryBot.create(:page, title: 'Child', slug: 'child', parent: home, status_id: Status[:published].id)
+      expect(child.part?('body')).to be(false)
+      expect(child.inherits_part?('body')).to be(true)
+    end
+
+    it '#has_or_inherits_part? covers both direct and inherited parts' do
+      home.parts.create(name: 'body', content: 'x')
+      child = FactoryBot.create(:page, title: 'Child', slug: 'child', parent: home, status_id: Status[:published].id)
+      expect(child.has_or_inherits_part?('body')).to be(true)
+      expect(child.has_or_inherits_part?('missing')).to be(false)
+    end
+  end
+
+  describe 'fields' do
+    it '#field looks up a field by name, case-insensitively' do
+      home.fields.create(name: 'Description', content: 'desc')
+      expect(home.field('description').content).to eq('desc')
+      expect(home.field(:Description).content).to eq('desc')
+    end
+
+    it '#field returns nil for an unknown field' do
+      expect(home.field('nope')).to be_nil
+    end
+  end
+
+  describe 'rendering' do
+    it '#render renders the body part when there is no layout' do
+      page = FactoryBot.create(:page, title: 'NoLayout', slug: 'nl', parent: home, status_id: Status[:published].id)
+      page.parts.create(name: 'body', content: 'Body: <r:title />')
+      expect(page.render).to eq('Body: NoLayout')
+    end
+
+    it '#render renders through the layout when one is present' do
+      layout = Layout.create!(name: 'Simple', content: 'Layout: <r:title />')
+      page = FactoryBot.create(:page, title: 'WithLayout', slug: 'wl', parent: home, status_id: Status[:published].id, layout: layout)
+      expect(page.render).to eq('Layout: WithLayout')
+    end
+
+    it '#render_part returns an empty string for a missing part' do
+      expect(home.render_part(:nonexistent)).to eq('')
+    end
+
+    it '#render_snippet parses the snippet content in the page context' do
+      snippet = FactoryBot.build(:snippet, name: 'greeting', content: 'Hello from <r:title />')
+      expect(home.render_snippet(snippet)).to eq('Hello from Home')
+    end
+  end
+
+  describe '.new_with_defaults' do
+    it 'builds a page with the configured default parts, fields, and status' do
+      page = Page.new_with_defaults
+      expect(page.parts.map(&:name)).to eq(%w[body extended])
+      expect(page.fields.map(&:name)).to eq(%w[Keywords Description])
+      expect(page.status).to eq(Status[:draft])
+    end
+  end
+
+  describe 'class helpers' do
+    it '.root returns the parentless page' do
+      home
+      expect(Page.root).to eq(home)
+    end
+
+    it '.date_column_names lists the date/time columns' do
+      expect(Page.date_column_names).to include('created_at', 'updated_at', 'published_at')
+    end
+
+    it '.descendant_class returns Page for blank/nil/"Page"' do
+      expect(Page.descendant_class(nil)).to eq(Page)
+      expect(Page.descendant_class('')).to eq(Page)
+      expect(Page.descendant_class('Page')).to eq(Page)
+    end
+
+    it '.descendant_class raises for an invalid class name' do
+      expect { Page.descendant_class('NotARealPage') }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe 'response defaults' do
+    it '#cache? is true' do
+      expect(home.cache?).to be(true)
+    end
+
+    it '#response_code is 200' do
+      expect(home.response_code).to eq(200)
+    end
+
+    it '#headers is an empty hash' do
+      expect(home.headers).to eq({})
+    end
+  end
+end

data/spec/models/rails_page_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe RailsPage do
+  subject(:page) { RailsPage.new }
+
+  it 'is a Page' do
+    expect(page).to be_a(Page)
+  end
+
+  describe '#url' do
+    it 'returns an explicitly assigned url' do
+      page.url = '/custom/path'
+      expect(page.url).to eq('/custom/path')
+    end
+  end
+
+  describe '#build_parts_from_hash!' do
+    it 'creates page parts from a content hash' do
+      page.build_parts_from_hash!('body' => 'Hello', 'sidebar' => 'World')
+      expect(page.part('body').content).to eq('Hello')
+      expect(page.part('sidebar').content).to eq('World')
+    end
+
+    it 'updates the content of an existing part' do
+      page.build_parts_from_hash!('body' => 'first')
+      page.build_parts_from_hash!('body' => 'second')
+      bodies = page.parts.select { |p| p.name == 'body' }
+      expect(bodies.size).to eq(1)
+      expect(bodies.first.content).to eq('second')
+    end
+  end
+end

data/spec/models/site_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Site do
+  def create_site(attrs = {})
+    Site.create!({ name: 'Test', base_domain: 'test.local', domain: 'test\\.local' }.merge(attrs))
+  end
+
+  describe '#url' do
+    let(:site) { create_site(base_domain: 'example.com') }
+
+    it 'returns the site root for no path' do
+      expect(site.url).to eq('http://example.com/')
+    end
+
+    it 'joins a path onto the base domain' do
+      expect(site.url('/about')).to eq('http://example.com/about')
+    end
+  end
+
+  describe '.find_for_host' do
+    it 'returns the default site for a blank hostname' do
+      default = create_site(name: 'Default', base_domain: 'localhost', domain: '')
+      expect(Site.find_for_host('')).to eq(default)
+    end
+
+    it 'matches a site by its base_domain' do
+      # No empty-domain site here: an empty domain pattern matches every host
+      # (Regexp.compile('') matches anything) and would shadow specific sites.
+      blog = create_site(name: 'Blog', base_domain: 'blog.example.com', domain: 'blog\\.example\\.com')
+      expect(Site.find_for_host('blog.example.com')).to eq(blog)
+    end
+
+    it 'falls back to the default site for an unknown host' do
+      default = create_site(name: 'Default', base_domain: 'localhost', domain: '')
+      expect(Site.find_for_host('unknown.example.com')).to eq(default)
+    end
+  end
+
+  describe '.default' do
+    it 'returns the site whose domain is empty' do
+      default = create_site(name: 'Default', base_domain: 'localhost', domain: '')
+      expect(Site.default).to eq(default)
+    end
+  end
+
+  describe '.catchall' do
+    it 'creates a workable default site when none exists' do
+      site = Site.catchall
+      expect(site).to be_persisted
+      expect(site.name).to eq('default_site')
+      expect(site.base_domain).to eq('localhost')
+    end
+  end
+
+  describe '.several?' do
+    before { Site.several = nil }
+
+    it 'is false with a single site' do
+      create_site
+      expect(Site.several?).to be(false)
+    end
+
+    it 'is true with more than one site' do
+      create_site(name: 'One', base_domain: 'one.local', domain: 'one\\.local')
+      create_site(name: 'Two', base_domain: 'two.local', domain: 'two\\.local')
+      expect(Site.several?).to be(true)
+    end
+  end
+
+  describe 'validations' do
+    it 'requires a name and base_domain' do
+      site = Site.new
+      site.valid?
+      expect(site.errors[:name]).to be_present
+      expect(site.errors[:base_domain]).to be_present
+    end
+
+    it 'requires a unique domain' do
+      create_site(domain: 'dup\\.local')
+      dup = Site.new(name: 'Dup', base_domain: 'dup2.local', domain: 'dup\\.local')
+      expect(dup).not_to be_valid
+      expect(dup.errors[:domain]).to be_present
+    end
+  end
+
+  describe 'homepage creation' do
+    it 'builds a homepage automatically after create' do
+      site = create_site(base_domain: 'hp.local', domain: 'hp\\.local')
+      expect(site.homepage).to be_present
+      expect(site.homepage.breadcrumb).to eq('Home')
+    end
+  end
+end

data/spec/models/snippet_finder_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe SnippetFinder do
+  describe '.finder_types' do
+    it 'looks in Snippet' do
+      expect(SnippetFinder.finder_types).to eq([Snippet])
+    end
+  end
+
+  describe '.find' do
+    it 'finds a snippet by id' do
+      snippet = FactoryBot.create(:snippet)
+      expect(SnippetFinder.find(snippet.id)).to eq(snippet)
+    end
+  end
+
+  describe '.find_by_name' do
+    it 'finds a snippet by name' do
+      snippet = FactoryBot.create(:snippet, name: 'sidebar')
+      expect(SnippetFinder.find_by_name('sidebar')).to eq(snippet)
+    end
+
+    it 'returns nil when no snippet matches' do
+      expect(SnippetFinder.find_by_name('does_not_exist')).to be_nil
+    end
+  end
+end

data/spec/models/snippet_tags_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe SnippetTags do
+  # In production the snippets extension mixes SnippetTags in. Extend a single
+  # page instance (as MenuRenderer is used) so the snippet/yield tags are
+  # available through Page#parse without mutating the global Page class.
+  let(:page) { Page.new(title: 'Host').tap { |p| p.extend(SnippetTags) } }
+
+  def render(input)
+    page.send(:parse, input)
+  end
+
+  describe '<r:snippet>' do
+    it 'renders the named snippet within the page' do
+      FactoryBot.create(:snippet, name: 'hello', content: 'Hello Snippet')
+      expect(render('<r:snippet name="hello" />')).to eq('Hello Snippet')
+    end
+
+    it 'substitutes the double-tag body for <r:yield/>' do
+      FactoryBot.create(:snippet, name: 'wrap', content: 'before <r:yield/> after')
+      expect(render('<r:snippet name="wrap">MIDDLE</r:snippet>')).to eq('before MIDDLE after')
+    end
+
+    it 'raises when the name attribute is missing' do
+      expect { render('<r:snippet />') }.to raise_error(StandardTags::TagError, /name.*attribute/)
+    end
+
+    it 'raises when the snippet does not exist' do
+      expect { render('<r:snippet name="nope" />') }
+        .to raise_error(SnippetTags::TagError, /snippet 'nope' not found/)
+    end
+
+    it 'caches a snippet looked up more than once in a render' do
+      FactoryBot.create(:snippet, name: 'twice', content: 'X')
+      expect(SnippetFinder).to receive(:find_by_name).once.and_call_original
+      render('<r:snippet name="twice" /><r:snippet name="twice" />')
+    end
+  end
+
+  describe '<r:yield>' do
+    it 'outputs nothing outside of a double-tag snippet' do
+      expect(render('<r:yield/>')).to eq('')
+    end
+  end
+end

data/spec/models/standard_tags/children_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe 'StandardTags: children tags' do
+  def render(page, input)
+    page.send(:parse, input)
+  end
+
+  let(:home) { FactoryBot.create(:home) }
+
+  # Three published children (ascending published_at) plus one draft, so we can
+  # exercise ordering, status filtering, limit/offset and pagination.
+  before do
+    FactoryBot.create(:page, title: 'Apple',  slug: 'apple',  parent: home, status_id: Status[:published].id, published_at: Time.zone.local(2020, 1, 1))
+    FactoryBot.create(:page, title: 'Banana', slug: 'banana', parent: home, status_id: Status[:published].id, published_at: Time.zone.local(2020, 1, 2))
+    FactoryBot.create(:page, title: 'Cherry', slug: 'cherry', parent: home, status_id: Status[:published].id, published_at: Time.zone.local(2020, 1, 3))
+    FactoryBot.create(:page, title: 'Zeta',   slug: 'zeta',   parent: home, status_id: Status[:draft].id)
+  end
+
+  describe '<r:children>' do
+    it 'expands its contents' do
+      expect(render(home, '<r:children>hello</r:children>')).to eq('hello')
+    end
+  end
+
+  describe '<r:children:count>' do
+    it 'counts published children by default status' do
+      expect(render(home, '<r:children:count status="published" />')).to eq('3')
+    end
+
+    it 'counts all non-virtual children with status="all"' do
+      expect(render(home, '<r:children:count status="all" />')).to eq('4')
+    end
+  end
+
+  describe '<r:children:each>' do
+    it 'iterates published children ordered by published_at ascending' do
+      expect(render(home, '<r:children:each status="published"><r:title /> </r:children:each>'))
+        .to eq('Apple Banana Cherry ')
+    end
+
+    it 'orders by a given field and direction' do
+      expect(render(home, '<r:children:each status="published" by="title" order="desc"><r:title /> </r:children:each>'))
+        .to eq('Cherry Banana Apple ')
+    end
+
+    it 'honors the limit attribute' do
+      expect(render(home, '<r:children:each status="published" by="title" limit="2"><r:title /> </r:children:each>'))
+        .to eq('Apple Banana ')
+    end
+
+    it 'honors the offset attribute' do
+      expect(render(home, '<r:children:each status="published" by="title" offset="1"><r:title /> </r:children:each>'))
+        .to eq('Banana Cherry ')
+    end
+
+    it 'includes non-virtual draft pages with status="all"' do
+      expect(render(home, '<r:children:each status="all" by="title"><r:title /> </r:children:each>'))
+        .to eq('Apple Banana Cherry Zeta ')
+    end
+
+    it 'raises when the by attribute is not a valid field' do
+      expect { render(home, '<r:children:each status="published" by="bogus"><r:title /></r:children:each>') }
+        .to raise_error(StandardTags::TagError, /`by'/)
+    end
+
+    it 'raises when the order attribute is invalid' do
+      expect { render(home, '<r:children:each status="published" order="sideways"><r:title /></r:children:each>') }
+        .to raise_error(StandardTags::TagError, /`order'/)
+    end
+
+    it 'raises when the status attribute is not a valid status' do
+      expect { render(home, '<r:children:each status="bogus"><r:title /></r:children:each>') }
+        .to raise_error(StandardTags::TagError, /`status'/)
+    end
+
+    it 'raises when the status attribute is omitted' do
+      expect { render(home, '<r:children:each><r:title /></r:children:each>') }
+        .to raise_error(StandardTags::TagError, /`status'/)
+    end
+
+    it 'raises when limit is not a positive number' do
+      expect { render(home, '<r:children:each status="published" limit="x"><r:title /></r:children:each>') }
+        .to raise_error(StandardTags::TagError, /limit/)
+    end
+  end
+
+  describe 'child context tags inside <r:children:each>' do
+    it 'maps <r:child> attribute tags to the current child' do
+      expect(render(home, '<r:children:each status="published" by="title"><r:child><r:title /></r:child> </r:children:each>'))
+        .to eq('Apple Banana Cherry ')
+    end
+
+    it 'renders <r:if_first> only for the first child' do
+      expect(render(home, '<r:children:each status="published" by="title"><r:if_first>[first]</r:if_first><r:title /> </r:children:each>'))
+        .to eq('[first]Apple Banana Cherry ')
+    end
+
+    it 'renders <r:unless_first> for every child but the first' do
+      expect(render(home, '<r:children:each status="published" by="title"><r:unless_first>, </r:unless_first><r:title /></r:children:each>'))
+        .to eq('Apple, Banana, Cherry')
+    end
+
+    it 'renders <r:if_last> only for the last child' do
+      expect(render(home, '<r:children:each status="published" by="title"><r:title /><r:if_last>[last]</r:if_last> </r:children:each>'))
+        .to eq('Apple Banana Cherry[last] ')
+    end
+
+    it 'renders <r:unless_last> for every child but the last' do
+      expect(render(home, '<r:children:each status="published" by="title"><r:title /><r:unless_last>, </r:unless_last></r:children:each>'))
+        .to eq('Apple, Banana, Cherry')
+    end
+
+    it 'renders a header only when it changes' do
+      # A constant header renders once (before the first child) then is suppressed.
+      expect(render(home, '<r:children:each status="published" by="title"><r:header>H</r:header><r:title /> </r:children:each>'))
+        .to eq('HApple Banana Cherry ')
+    end
+  end
+
+  describe '<r:children:first> and <r:children:last>' do
+    it 'renders the first child (by published_at)' do
+      expect(render(home, '<r:children:first status="published"><r:title /></r:children:first>')).to eq('Apple')
+    end
+
+    it 'renders the last child (by published_at)' do
+      expect(render(home, '<r:children:last status="published"><r:title /></r:children:last>')).to eq('Cherry')
+    end
+
+    it 'respects ordering options when picking the first child' do
+      expect(render(home, '<r:children:first status="published" by="title" order="desc"><r:title /></r:children:first>')).to eq('Cherry')
+    end
+  end
+
+  describe 'pagination' do
+    # The pagination *controls* are rendered by the will_paginate view helper,
+    # which needs a view context that a model-level parse does not have, so we
+    # stub that layer and assert the results-slicing behavior of the tag.
+    before do
+      allow(home).to receive(:will_paginate).and_return('[controls]')
+      allow(home).to receive(:will_paginate_options).and_return({})
+    end
+
+    it 'renders only the current page of children plus pagination controls' do
+      home.pagination_parameters = { page: 1, per_page: 2 }
+      expect(render(home, '<r:children:each status="published" by="title" paginated="true" per_page="2"><r:title /> </r:children:each>'))
+        .to eq('Apple Banana [controls]')
+    end
+
+    it 'renders the second page of children' do
+      home.pagination_parameters = { page: 2, per_page: 2 }
+      expect(render(home, '<r:children:each status="published" by="title" paginated="true" per_page="2"><r:title /> </r:children:each>'))
+        .to eq('Cherry [controls]')
+    end
+
+    it 'renders nothing for the standalone pagination tag when there is no paginated list' do
+      expect(render(home, '<r:pagination />')).to eq('')
+    end
+  end
+end