trusty-cms 7.1.2 → 7.1.3

data/spec/models/standard_tags/content_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe 'StandardTags: <r:content>' do
+  # Render radius markup in the context of the given page.
+  def render(page, input)
+    page.send(:parse, input)
+  end
+
+  let(:page) { FactoryBot.create(:page, title: 'Home') }
+
+  # 1. Happy path: renders the default `body` part.
+  it 'renders the body part by default' do
+    page.parts.create(name: 'body', content: 'Hello world')
+    expect(render(page, '<r:content />')).to eq('Hello world')
+  end
+
+  # 2. Named part via the `part` attribute.
+  it 'renders a named part when given the part attribute' do
+    page.parts.create(name: 'sidebar', content: 'Sidebar text')
+    expect(render(page, '<r:content part="sidebar" />')).to eq('Sidebar text')
+  end
+
+  # 3. Missing part -> `part` is nil -> renders empty (line 500 leaves result nil).
+  it 'renders nothing when the requested part does not exist' do
+    expect(render(page, '<r:content part="nonexistent" />')).to eq('')
+  end
+
+  # 7. Nested radius tags inside the part are parsed by render_snippet.
+  it 'parses radius tags contained in the part' do
+    page.parts.create(name: 'body', content: 'Title is <r:title />')
+    expect(render(page, '<r:content />')).to eq('Title is Home')
+  end
+
+  describe 'inherit' do
+    let(:parent) { FactoryBot.create(:page, title: 'Parent') }
+    let(:child)  { FactoryBot.create(:page, title: 'Child', parent: parent) }
+
+    before { parent.parts.create(name: 'body', content: 'Parent body') }
+
+    # 4. inherit="true" walks up to the parent's part.
+    it 'renders an inherited part from the parent when inherit is true' do
+      expect(render(child, '<r:content inherit="true" />')).to eq('Parent body')
+    end
+
+    # 5. Default (inherit=false) does not walk up.
+    it 'renders nothing when the part is missing and inherit is false' do
+      expect(render(child, '<r:content />')).to eq('')
+    end
+  end
+
+  # 6. Recursion guard raises TagError (errors are raised in the test env).
+  it 'raises a TagError on recursive rendering of the same part' do
+    page.parts.create(name: 'body', content: 'loop <r:content />')
+    expect { render(page, '<r:content />') }
+      .to raise_error(StandardTags::TagError, /Recursion error/)
+  end
+
+  # 8. A non-boolean value for a boolean attribute raises TagError.
+  it 'raises a TagError when inherit is not a boolean' do
+    page.parts.create(name: 'body', content: 'Hello')
+    expect { render(page, '<r:content inherit="maybe" />') }
+      .to raise_error(StandardTags::TagError)
+  end
+end
+
+describe 'StandardTags: <r:if_content>' do
+  def render(page, input)
+    page.send(:parse, input)
+  end
+
+  let(:page) { FactoryBot.create(:page, title: 'Home') }
+
+  it 'expands when the default body part exists' do
+    page.parts.create(name: 'body', content: 'x')
+    expect(render(page, '<r:if_content>shown</r:if_content>')).to eq('shown')
+  end
+
+  it 'does not expand when the part is missing' do
+    expect(render(page, '<r:if_content>shown</r:if_content>')).to eq('')
+  end
+
+  describe 'multiple parts' do
+    before { page.parts.create(name: 'body', content: 'x') }
+
+    it 'find="all" (default) does not expand when one listed part is missing' do
+      expect(render(page, '<r:if_content part="body, sidebar">shown</r:if_content>')).to eq('')
+    end
+
+    it 'find="all" expands when every listed part exists' do
+      page.parts.create(name: 'sidebar', content: 'y')
+      expect(render(page, '<r:if_content part="body, sidebar">shown</r:if_content>')).to eq('shown')
+    end
+
+    it 'find="any" expands when at least one listed part exists' do
+      expect(render(page, '<r:if_content part="body, sidebar" find="any">shown</r:if_content>')).to eq('shown')
+    end
+  end
+
+  describe 'inherit' do
+    let(:parent) { FactoryBot.create(:page, title: 'Parent') }
+    let(:child)  { FactoryBot.create(:page, title: 'Child', parent: parent) }
+
+    before { parent.parts.create(name: 'body', content: 'Parent body') }
+
+    it 'expands when an ancestor has the part and inherit is true' do
+      expect(render(child, '<r:if_content inherit="true">shown</r:if_content>')).to eq('shown')
+    end
+
+    it 'does not expand for an inherited part when inherit is false' do
+      expect(render(child, '<r:if_content>shown</r:if_content>')).to eq('')
+    end
+  end
+
+  it 'raises a TagError for an invalid find value' do
+    page.parts.create(name: 'body', content: 'x')
+    expect { render(page, '<r:if_content find="bogus">shown</r:if_content>') }
+      .to raise_error(StandardTags::TagError)
+  end
+end
+
+describe 'StandardTags: <r:unless_content>' do
+  def render(page, input)
+    page.send(:parse, input)
+  end
+
+  let(:page) { FactoryBot.create(:page, title: 'Home') }
+
+  it 'expands when the default body part is missing' do
+    expect(render(page, '<r:unless_content>shown</r:unless_content>')).to eq('shown')
+  end
+
+  it 'does not expand when the part exists' do
+    page.parts.create(name: 'body', content: 'x')
+    expect(render(page, '<r:unless_content>shown</r:unless_content>')).to eq('')
+  end
+
+  describe 'multiple parts' do
+    before { page.parts.create(name: 'body', content: 'x') }
+
+    it 'find="all" (default) expands when at least one listed part is missing' do
+      expect(render(page, '<r:unless_content part="body, sidebar">shown</r:unless_content>')).to eq('shown')
+    end
+
+    it 'find="any" does not expand when any listed part is found' do
+      expect(render(page, '<r:unless_content part="body, sidebar" find="any">shown</r:unless_content>')).to eq('')
+    end
+
+    it 'find="any" expands when none of the listed parts exist' do
+      expect(render(page, '<r:unless_content part="header, sidebar" find="any">shown</r:unless_content>')).to eq('shown')
+    end
+  end
+
+  describe 'inherit' do
+    let(:parent) { FactoryBot.create(:page, title: 'Parent') }
+    let(:child)  { FactoryBot.create(:page, title: 'Child', parent: parent) }
+
+    before { parent.parts.create(name: 'body', content: 'Parent body') }
+
+    it 'does not expand when an ancestor has the part and inherit is true' do
+      expect(render(child, '<r:unless_content inherit="true">shown</r:unless_content>')).to eq('')
+    end
+  end
+
+  it 'raises a TagError for an invalid find value' do
+    expect { render(page, '<r:unless_content find="bogus">shown</r:unless_content>') }
+      .to raise_error(StandardTags::TagError)
+  end
+end

data/spec/models/standard_tags/meta_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe 'StandardTags: <r:meta>' do
+  def render(page, input)
+    page.send(:parse, input)
+  end
+
+  let(:page) { FactoryBot.create(:page, title: 'Home') }
+
+  describe '<r:meta:description>' do
+    it 'wraps the description field in a meta element by default' do
+      page.fields.create(name: 'description', content: 'A page')
+      expect(render(page, '<r:meta:description />'))
+        .to eq('<meta name="description" content="A page" />')
+    end
+
+    it 'escapes HTML in the description content' do
+      page.fields.create(name: 'description', content: 'Tom & Jerry <b>')
+      expect(render(page, '<r:meta:description />'))
+        .to eq('<meta name="description" content="Tom &amp; Jerry &lt;b&gt;" />')
+    end
+
+    it 'returns the raw (escaped) content without a wrapper when tag="false"' do
+      page.fields.create(name: 'description', content: 'Tom & Jerry')
+      expect(render(page, '<r:meta:description tag="false" />')).to eq('Tom &amp; Jerry')
+    end
+
+    it 'renders an empty content element when there is no description field' do
+      expect(render(page, '<r:meta:description />'))
+        .to eq('<meta name="description" content="" />')
+    end
+  end
+
+  describe '<r:meta:keywords>' do
+    it 'wraps the keywords field in a meta element by default' do
+      page.fields.create(name: 'keywords', content: 'ruby, cms')
+      expect(render(page, '<r:meta:keywords />'))
+        .to eq('<meta name="keywords" content="ruby, cms" />')
+    end
+
+    it 'returns the raw (escaped) content without a wrapper when tag="false"' do
+      page.fields.create(name: 'keywords', content: 'a & b')
+      expect(render(page, '<r:meta:keywords tag="false" />')).to eq('a &amp; b')
+    end
+
+    it 'renders an empty content element when there is no keywords field' do
+      expect(render(page, '<r:meta:keywords />'))
+        .to eq('<meta name="keywords" content="" />')
+    end
+  end
+
+  describe '<r:meta>' do
+    it 'concatenates the description and keywords elements when used as a single tag' do
+      page.fields.create(name: 'description', content: 'A page')
+      page.fields.create(name: 'keywords', content: 'ruby')
+      expect(render(page, '<r:meta />'))
+        .to eq('<meta name="description" content="A page" /><meta name="keywords" content="ruby" />')
+    end
+
+    it 'expands its contents when used as a double tag' do
+      expect(render(page, '<r:meta>inner <r:title /></r:meta>')).to eq('inner Home')
+    end
+  end
+end
+
+describe 'StandardTags: <r:site>' do
+  def render(page, input)
+    page.send(:parse, input)
+  end
+
+  let(:page) { FactoryBot.create(:page, title: 'Home') }
+
+  it 'expands the contents of the site container tag' do
+    expect(render(page, '<r:site>content</r:site>')).to eq('content')
+  end
+
+  it 'renders the configured site title' do
+    TrustyCms::Config['site.title'] = 'My Site'
+    expect(render(page, '<r:site:title />')).to eq('My Site')
+  end
+
+  it 'renders the configured site host' do
+    TrustyCms::Config['site.host'] = 'example.com'
+    expect(render(page, '<r:site:host />')).to eq('example.com')
+  end
+end

data/spec/models/standard_tags_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'Standard Tags' do
+  # Helper: render a radius string in the context of the given page.
+  def render(page, input)
+    page.send(:parse, input)
+  end
+
+  let(:home) do
+    FactoryBot.create(:home, title: 'Home', breadcrumb: 'Home')
+  end
+
+  describe '<r:page>' do
+    it 'sets the local page to the global page' do
+      expect(render(home, '<r:page><r:title /></r:page>')).to eq('Home')
+    end
+  end
+
+  describe 'attribute tags' do
+    it 'renders <r:title />' do
+      expect(render(home, '<r:title />')).to eq('Home')
+    end
+
+    it 'renders <r:breadcrumb />' do
+      expect(render(home, '<r:breadcrumb />')).to eq('Home')
+    end
+
+    it 'renders <r:slug />' do
+      expect(render(home, '<r:slug />')).to eq('/')
+    end
+  end
+end

data/spec/models/status_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Status do
+  describe '#initialize' do
+    it 'assigns id and name from options' do
+      status = Status.new(id: 1, name: 'Draft')
+      expect(status.id).to eq(1)
+      expect(status.name).to eq('Draft')
+    end
+
+    it 'accepts string keys' do
+      status = Status.new('id' => 1, 'name' => 'Draft')
+      expect(status.id).to eq(1)
+      expect(status.name).to eq('Draft')
+    end
+  end
+
+  describe '#symbol' do
+    it 'returns the downcased name as a symbol' do
+      expect(Status.new(name: 'Published').symbol).to eq(:published)
+    end
+  end
+
+  describe '.[]' do
+    it 'finds a status by its symbol' do
+      expect(Status[:published].name).to eq('Published')
+    end
+
+    it 'is case-insensitive' do
+      expect(Status['Published']).to eq(Status[:published])
+    end
+
+    it 'returns nil for an unknown symbol' do
+      expect(Status[:nonexistent]).to be_nil
+    end
+  end
+
+  describe '.find' do
+    it 'finds a status by its id' do
+      expect(Status.find(100).name).to eq('Published')
+    end
+
+    it 'matches ids regardless of type' do
+      expect(Status.find('100')).to eq(Status.find(100))
+    end
+
+    it 'returns nil for an unknown id' do
+      expect(Status.find(999)).to be_nil
+    end
+  end
+
+  describe '.selectable' do
+    it 'returns all defined statuses' do
+      expect(Status.selectable.map(&:name)).to eq(%w[Draft Reviewed Scheduled Published Hidden])
+    end
+  end
+
+  describe '.selectable_values' do
+    it 'returns the names of all selectable statuses' do
+      expect(Status.selectable_values).to eq(%w[Draft Reviewed Scheduled Published Hidden])
+    end
+  end
+end

data/spec/models/text_filter_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+# Defined at load time so TextFilter.inherited fires and registers a descendant.
+class SpecSampleFilter < TextFilter
+  def filter(text)
+    "[#{text}]"
+  end
+end
+
+describe TextFilter do
+  describe '#filter' do
+    it 'returns the text unchanged for the base filter' do
+      expect(TextFilter.new.filter('hello')).to eq('hello')
+    end
+  end
+
+  describe '.filter' do
+    it 'delegates to the singleton instance' do
+      expect(TextFilter.filter('hello')).to eq('hello')
+      expect(SpecSampleFilter.filter('hello')).to eq('[hello]')
+    end
+  end
+
+  describe '.inherited' do
+    it 'derives a filter_name from the subclass name' do
+      expect(SpecSampleFilter.filter_name).to eq('Spec Sample')
+    end
+  end
+
+  describe '.descendants_names' do
+    it 'includes the names of registered descendants, sorted' do
+      names = TextFilter.descendants_names
+      expect(names).to include('Spec Sample')
+      expect(names).to eq(names.sort)
+    end
+  end
+
+  describe '.find_descendant' do
+    it 'finds a descendant by its filter_name' do
+      expect(TextFilter.find_descendant('Spec Sample')).to eq(SpecSampleFilter)
+    end
+
+    it 'returns nil when no descendant matches' do
+      expect(TextFilter.find_descendant('No Such Filter')).to be_nil
+    end
+  end
+end

data/spec/models/trusty_cms/config_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe TrustyCms::Config do
+  # The custom #value= setter calls save!, and the config table is exempt from
+  # DatabaseCleaner truncation, so a saved row would leak across examples and
+  # collide on the unique key index. Build unsaved instances and assign the raw
+  # attribute with self[:value]= (write_attribute) to bypass the setter.
+  def config(key, value = nil)
+    TrustyCms::Config.new(key: key).tap do |c|
+      c[:value] = value unless value.nil?
+    end
+  end
+
+  describe '#boolean?' do
+    it 'is true when the key ends with a question mark' do
+      expect(config('feature.enabled?').boolean?).to be(true)
+    end
+
+    it 'is false for an ordinary key with no definition' do
+      expect(config('feature.name').boolean?).to be(false)
+    end
+  end
+
+  describe '#checked?' do
+    it 'is true for a boolean setting whose value is "true"' do
+      expect(config('x?', 'true').checked?).to be(true)
+    end
+
+    it 'is false for a boolean setting whose value is not "true"' do
+      expect(config('x?', 'false').checked?).to be(false)
+    end
+  end
+
+  describe '#value' do
+    it 'returns a boolean for a boolean setting' do
+      expect(config('x?', 'true').value).to be(true)
+    end
+
+    it 'returns the raw string for a non-boolean setting' do
+      expect(config('plain', 'hello').value).to eq('hello')
+    end
+  end
+
+  describe '#selector?' do
+    it 'is false when the definition does not restrict the value' do
+      expect(config('plain').selector?).to be(false)
+    end
+  end
+
+  describe '#definition' do
+    it 'returns a Definition even when none was declared' do
+      expect(config('undeclared').definition).to be_a(TrustyCms::Config::Definition)
+    end
+  end
+
+  describe '.site_settings' do
+    it 'lists the site-level settings' do
+      expect(TrustyCms::Config.site_settings).to eq(%w[site.title site.host local.timezone])
+    end
+  end
+
+  describe '.default_settings' do
+    it 'lists the default settings' do
+      expect(TrustyCms::Config.default_settings).to eq(
+        %w[defaults.locale defaults.page.filter defaults.page.parts defaults.page.fields defaults.page.status]
+      )
+    end
+  end
+end

data/spec/models/trusty_cms/page_response_cache_director_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe TrustyCms::PageResponseCacheDirector do
+  let(:listener) { double('listener') }
+
+  subject(:director) { described_class.new(page, listener) }
+
+  describe '.cache_timeout' do
+    around do |example|
+      original = described_class.cache_timeout
+      example.run
+      described_class.cache_timeout = original
+    end
+
+    it 'defaults to five minutes' do
+      described_class.instance_variable_set(:@cache_timeout, nil)
+      expect(described_class.cache_timeout).to eq(5.minutes)
+    end
+
+    it 'can be overridden' do
+      described_class.cache_timeout = 10.minutes
+      expect(described_class.cache_timeout).to eq(10.minutes)
+    end
+  end
+
+  describe '#set_cache_control' do
+    context 'when the request and page are both cacheable' do
+      before { allow(listener).to receive(:cacheable_request?).and_return(true) }
+
+      context 'and the page defines its own cache_timeout' do
+        let(:page) { double('page', cache?: true, cache_timeout: 2.minutes) }
+
+        it 'sets a public expiry using the page timeout' do
+          expect(listener).to receive(:set_expiry).with(2.minutes, public: true, private: false)
+          director.set_cache_control
+        end
+      end
+
+      context 'and the page has no cache_timeout' do
+        let(:page) { double('page', cache?: true) }
+
+        it 'sets a public expiry using the class timeout' do
+          allow(described_class).to receive(:cache_timeout).and_return(5.minutes)
+          expect(listener).to receive(:set_expiry).with(5.minutes, public: true, private: false)
+          director.set_cache_control
+        end
+      end
+    end
+
+    context 'when the page is not cacheable' do
+      let(:page) { double('page', cache?: false) }
+      before { allow(listener).to receive(:cacheable_request?).and_return(true) }
+
+      it 'sends a no-cache, private response and clears the etag' do
+        expect(listener).to receive(:set_expiry).with(nil, private: true, 'no-cache' => true)
+        expect(listener).to receive(:set_etag).with('')
+        director.set_cache_control
+      end
+    end
+
+    context 'when the request is not cacheable' do
+      let(:page) { double('page', cache?: true) }
+      before { allow(listener).to receive(:cacheable_request?).and_return(false) }
+
+      it 'sends a non-cacheable response' do
+        expect(listener).to receive(:set_expiry).with(nil, private: true, 'no-cache' => true)
+        expect(listener).to receive(:set_etag).with('')
+        director.set_cache_control
+      end
+    end
+  end
+end

data/spec/models/user_action_observer_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe UserActionObserver do
+  let(:observer) { UserActionObserver.instance }
+  let(:user) { User.new }
+
+  # Restore the original thread-local rather than clobbering it with nil, so
+  # the spec stays isolated and order-independent.
+  around do |example|
+    original = Thread.current[:current_user]
+    example.run
+  ensure
+    Thread.current[:current_user] = original
+  end
+
+  describe 'current_user' do
+    it 'stores the current user on the class in thread-local storage' do
+      UserActionObserver.current_user = user
+      expect(UserActionObserver.current_user).to eq(user)
+      expect(Thread.current[:current_user]).to eq(user)
+    end
+
+    it 'delegates the instance writer and reader to the class' do
+      observer.current_user = user
+      expect(UserActionObserver.current_user).to eq(user)
+      expect(observer.current_user).to eq(user)
+    end
+  end
+
+  describe 'callbacks' do
+    it 'does not raise on before_create' do
+      expect { observer.before_create(user) }.not_to raise_error
+    end
+
+    it 'does not raise on before_update' do
+      expect { observer.before_update(user) }.not_to raise_error
+    end
+  end
+end