trusty-cms 7.1.2 → 7.1.3

data/spec/lib/trusty_cms/config_cache_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+# The cache layer of TrustyCms::Config leans on Rails.cache and File.mtime,
+# both of which can shift across Rails upgrades. Pin the round-trip.
+describe TrustyCms::Config, 'caching' do
+  # Seed a known key so the read/round-trip assertions can't pass vacuously on
+  # an empty config table. The config table is exempt from truncation, so this
+  # probe row is removed explicitly after each example.
+  let(:probe_key) { 'spec.cache_probe' }
+  let(:probe_value) { 'probe-value' }
+
+  before { TrustyCms::Config[probe_key] = probe_value }
+
+  after do
+    TrustyCms::Config.where(key: probe_key).delete_all
+    TrustyCms::Config.initialize_cache # leave the cache good for whatever runs next
+  end
+
+  describe '.ensure_cache_file' do
+it 'creates the cache file' do
+  File.delete(TrustyCms::Config.cache_file) if File.exist?(TrustyCms::Config.cache_file)
+  expect(TrustyCms::Config.cache_file_exists?).to be(false)
+
+  TrustyCms::Config.ensure_cache_file
+  expect(TrustyCms::Config.cache_file_exists?).to be(true)
+  expect(File.file?(TrustyCms::Config.cache_file)).to be(true)
+end
+  end
+
+  describe '.initialize_cache' do
+    it 'writes the full config hash into Rails.cache' do
+      TrustyCms::Config.initialize_cache
+      expect(Rails.cache.read('TrustyCms::Config')).to eq(TrustyCms::Config.to_hash)
+    end
+
+    it 'leaves the cache non-stale' do
+      TrustyCms::Config.initialize_cache
+      expect(TrustyCms::Config.stale_cache?).to be(false)
+    end
+  end
+
+  describe '.stale_cache?' do
+    it 'is true when the stored mtime no longer matches the cache file' do
+      TrustyCms::Config.initialize_cache
+      Rails.cache.write('TrustyCms.cache_mtime', Time.at(0))
+      expect(TrustyCms::Config.stale_cache?).to be(true)
+    end
+  end
+
+  describe '.[]' do
+    it 'reads a value through the cache' do
+      TrustyCms::Config.initialize_cache
+      expect(TrustyCms::Config[probe_key]).to eq(probe_value)
+    end
+
+    it 'rebuilds a stale cache before returning a value' do
+      TrustyCms::Config.initialize_cache
+      Rails.cache.write('TrustyCms.cache_mtime', Time.at(0)) # force staleness
+
+      expect(TrustyCms::Config[probe_key]).to eq(probe_value)
+      expect(TrustyCms::Config.stale_cache?).to be(false)
+    end
+  end
+
+  describe '.to_hash' do
+    it 'returns a hash keyed by config key, including seeded entries' do
+      hash = TrustyCms::Config.to_hash
+      expect(hash).to be_a(Hash)
+      expect(hash).to include(probe_key => probe_value)
+      expect(hash.keys).to all(be_a(String))
+    end
+  end
+end

data/spec/models/admins_site_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe AdminsSite do
+  it 'uses the admins_sites table' do
+    expect(AdminsSite.table_name).to eq('admins_sites')
+  end
+
+  describe 'associations' do
+    it 'belongs to an admin that is a User' do
+      association = AdminsSite.reflect_on_association(:admin)
+      expect(association.macro).to eq(:belongs_to)
+      expect(association.options[:class_name]).to eq('User')
+    end
+
+    it 'belongs to a site' do
+      expect(AdminsSite.reflect_on_association(:site).macro).to eq(:belongs_to)
+    end
+  end
+end

data/spec/models/asset_spec.rb

@@ -259,4 +259,228 @@ RSpec.describe Asset, type: :model do
       expect(asset.public_url('normal')).to eq('https://s3.amazonaws.com/bucket/randomlegacykey')
     end
   end
+
+  # Shared helpers for the blocks below.
+  def register_image_and_other_types
+    AssetType.new(:image, styles: :standard, extensions: %w[png], mime_types: %w[image/png]) unless AssetType.known?(:image)
+    AssetType.new(:other, icon: 'unknown') unless AssetType.known?(:other)
+  end
+
+  def png_bytes
+    Base64.decode64('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg==')
+  end
+
+  def attach_png(filename: 'pixel.png', **attrs)
+    io = StringIO.new(png_bytes)
+    io.set_encoding(Encoding::BINARY)
+    described_class.new(attrs).tap do |asset|
+      asset.asset.attach(io: io, filename: filename, content_type: 'image/png')
+      asset.save!
+    end
+  end
+
+  describe 'unattached accessors' do
+    before { register_image_and_other_types }
+
+    it 'falls back to the stored columns when nothing is attached' do
+      asset = described_class.new(asset_file_name: 'legacy.PNG', asset_content_type: 'image/png', asset_file_size: 42)
+
+      expect(asset.filename).to eq('legacy.PNG')
+      expect(asset.content_type).to eq('image/png')
+      expect(asset.byte_size).to eq(42)
+    end
+
+    it 'derives basename and extension from the stored filename' do
+      asset = described_class.new(asset_file_name: 'legacy.PNG')
+
+      expect(asset.basename).to eq('legacy')
+      expect(asset.original_extension).to eq('png')
+      expect(asset.extension('original')).to eq('png')
+    end
+
+    it 'returns the original extension for a style with no defined format' do
+      asset = described_class.new(asset_file_name: 'legacy.png')
+
+      expect(asset.extension('no_such_style')).to eq('png')
+    end
+  end
+
+  describe 'geometry' do
+    before { register_image_and_other_types }
+
+    it 'reports width, height and aspect from the original dimensions' do
+      asset = described_class.new(original_width: 100, original_height: 50)
+
+      expect(asset.width).to eq(100)
+      expect(asset.height).to eq(50)
+      expect(asset.aspect).to eq(2.0)
+      expect(asset.dimensions_known?).to be(true)
+    end
+
+    it 'reports a horizontal orientation for a wide asset' do
+      asset = described_class.new(original_width: 100, original_height: 50)
+
+      expect(asset.orientation).to eq('horizontal')
+      expect(asset.horizontal?).to be(true)
+      expect(asset.vertical?).to be(false)
+      expect(asset.square?).to be(false)
+    end
+
+    it 'reports a vertical orientation for a tall asset' do
+      asset = described_class.new(original_width: 50, original_height: 100)
+
+      expect(asset.orientation).to eq('vertical')
+      expect(asset.vertical?).to be(true)
+    end
+
+    it 'reports a square orientation for an equal-sided asset' do
+      asset = described_class.new(original_width: 100, original_height: 100)
+
+      expect(asset.orientation).to eq('square')
+      expect(asset.square?).to be(true)
+    end
+
+    it 'is not dimensions_known? without stored dimensions' do
+      expect(described_class.new.dimensions_known?).to be(false)
+    end
+
+    it 'raises a StyleError for a style that is not defined' do
+      asset = described_class.new(original_width: 100, original_height: 50)
+
+      expect { asset.geometry('no_such_style') }.to raise_error(TrustyCms::StyleError)
+    end
+  end
+
+  describe '#active_storage_transformations' do
+    subject(:asset) { described_class.new }
+
+    it 'resizes to fill for cropping modifiers' do
+      expect(asset.send(:active_storage_transformations, '100x80#')).to eq(resize_to_fill: [100, 80])
+    end
+
+    it 'resizes to limit for the shrink modifier' do
+      expect(asset.send(:active_storage_transformations, '100x80>')).to eq(resize_to_limit: [100, 80])
+    end
+
+    it 'resizes to limit when there is no modifier' do
+      expect(asset.send(:active_storage_transformations, '100x80')).to eq(resize_to_limit: [100, 80])
+    end
+
+    it 'returns no transformations for a blank geometry' do
+      expect(asset.send(:active_storage_transformations, '')).to eq({})
+    end
+  end
+
+  describe 'scopes' do
+    before { register_image_and_other_types }
+
+    let!(:image) { attach_png(caption: 'a picture', title: 'Pixel') }
+
+    describe '.latest' do
+      it 'includes recently created assets up to the limit' do
+        expect(described_class.latest(5)).to include(image)
+      end
+    end
+
+    describe '.of_types' do
+      it 'includes assets whose blob content type matches the given types' do
+        expect(described_class.of_types([:image])).to include(image)
+      end
+
+      it 'returns none when the given types have no mime types' do
+        expect(described_class.of_types([:no_such_type])).to be_empty
+      end
+    end
+
+    describe '.matching' do
+      it 'matches on filename, title or caption, case-insensitively' do
+        expect(described_class.matching('PIXEL')).to include(image)
+        expect(described_class.matching('picture')).to include(image)
+      end
+    end
+
+    describe '.excepting' do
+      it 'excludes the given asset ids' do
+        expect(described_class.excepting([image.id]).to_sql).to match(/NOT IN/)
+        expect(described_class.excepting([image.id])).not_to include(image)
+      end
+
+      it 'adds no exclusion when given an empty list' do
+        expect(described_class.excepting([])).to eq({})
+      end
+    end
+  end
+
+  describe '#attached_to?' do
+    before { register_image_and_other_types }
+
+    it 'is true for a page the asset is attached to, false otherwise' do
+      asset = attach_png
+      page = FactoryBot.create(:page, title: 'Attached')
+      other_page = FactoryBot.create(:page, title: 'Unattached')
+      asset.pages << page
+
+      expect(asset.attached_to?(page)).to be(true)
+      expect(asset.attached_to?(other_page)).to be(false)
+    end
+  end
+
+  describe 'class helpers' do
+    before { register_image_and_other_types }
+
+    it 'exposes the known asset type names' do
+      expect(described_class.known_types).to eq(AssetType.known_types)
+    end
+
+    it 'lists ransackable attributes' do
+      expect(described_class.ransackable_attributes).to include('title', 'caption', 'uuid')
+    end
+
+    it 'exposes the image thumbnail sizes and names' do
+      expect(described_class.thumbnail_sizes).to eq(AssetType.find(:image).active_storage_styles)
+      expect(described_class.thumbnail_names).to eq(described_class.thumbnail_sizes.keys)
+    end
+
+    it 'builds thumbnail options with an Original entry first' do
+      expect(described_class.thumbnail_options.first).to eq(['Original (as uploaded)', 'original'])
+    end
+
+    it 'describes hash-style thumbnails as "id: geometry as format"' do
+      options = described_class.thumbnail_options
+
+      expect(options).to include(['icon: 50x50# as png', :icon])
+      # Every option is a [description, id] pair with a string description.
+      expect(options).to all(satisfy { |desc, _id| desc.is_a?(String) })
+    end
+
+    it 'represents "original" only once, via the explicit entry (no blank :original option)' do
+      ids = described_class.thumbnail_options.map(&:last)
+
+      expect(ids).to include('original')          # the explicit "Original (as uploaded)" entry
+      expect(ids).not_to include(:original)        # not the blank one built from the :original style
+      expect(ids.count { |id| id.to_s == 'original' }).to eq(1)
+    end
+  end
+
+  describe '.describe_style' do
+    it 'renders a hash style as geometry and format' do
+      expect(described_class.describe_style(geometry: '100x100#', format: :png)).to eq('100x100# as png')
+    end
+
+    it 'omits a missing format' do
+      expect(described_class.describe_style(geometry: '640x640>')).to eq('640x640>')
+    end
+
+    it 'renders an empty hash as a blank string' do
+      expect(described_class.describe_style({})).to eq('')
+    end
+
+    it 'joins an array style with " as "' do
+      expect(described_class.describe_style(['100x100', 'png'])).to eq('100x100 as png')
+    end
+
+    it 'stringifies a plain style' do
+      expect(described_class.describe_style('100x100#')).to eq('100x100#')
+    end
+  end
 end

data/spec/models/asset_type_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe AssetType do
+  # AssetType keeps its registry in class variables, so registrations persist
+  # for the whole suite. Register uniquely-named types (guarded by .known?) so
+  # these examples don't depend on what other specs have registered.
+  before(:all) do
+    AssetType.new(:other, icon: 'unknown') unless AssetType.known?(:other)
+    unless AssetType.known?(:spec_image)
+      AssetType.new(:spec_image,
+                    icon: 'image',
+                    styles: :standard,
+                    extensions: %w[spx],
+                    mime_types: %w[image/spectest])
+    end
+  end
+
+  let(:image) { AssetType.find(:spec_image) }
+
+  describe '#plural' do
+    it 'pluralizes the name' do
+      expect(image.plural).to eq('spec_images')
+    end
+  end
+
+  describe '#mime_types' do
+    it 'returns the configured mime types' do
+      expect(image.mime_types).to eq(%w[image/spectest])
+    end
+  end
+
+  describe '#condition' do
+    it 'builds an IN clause over its mime types' do
+      sql, *values = image.condition
+      expect(sql).to match(/asset_content_type IN/)
+      expect(values).to eq(%w[image/spectest])
+    end
+  end
+
+  describe '#non_condition' do
+    it 'builds a NOT IN clause over its mime types' do
+      sql, *values = image.non_condition
+      expect(sql).to match(/NOT asset_content_type IN/)
+      expect(values).to eq(%w[image/spectest])
+    end
+  end
+
+  describe '#standard_styles' do
+    it 'defines icon, thumbnail and original styles' do
+      expect(image.standard_styles.keys).to match_array(%i[icon thumbnail original])
+    end
+  end
+
+  describe '#normalize_style_rules' do
+    it 'wraps a bare geometry string in a hash' do
+      expect(image.normalize_style_rules(small: '100x100')).to eq(small: { geometry: '100x100' })
+    end
+
+    it 'parses a key=value rule string into a hash' do
+      result = image.normalize_style_rules(big: 'geometry=640x640,format=jpg')
+      expect(result[:big]).to eq(geometry: '640x640', format: 'jpg')
+    end
+  end
+
+  describe '.known?' do
+    it 'is true for a registered type' do
+      expect(AssetType.known?(:spec_image)).to be(true)
+    end
+
+    it 'is false for an unregistered type' do
+      expect(AssetType.known?(:nonexistent)).to be(false)
+    end
+  end
+
+  describe '.find and .[]' do
+    it 'looks up a type by name' do
+      expect(AssetType.find(:spec_image)).to eq(image)
+    end
+
+    it 'aliases .[] to .find' do
+      expect(AssetType[:spec_image]).to eq(image)
+    end
+
+    it 'returns nil for an unknown type' do
+      expect(AssetType.find(:nonexistent)).to be_nil
+    end
+  end
+
+  describe '.from_extension' do
+    it 'finds a type by a registered extension' do
+      expect(AssetType.from_extension('spx')).to eq(image)
+    end
+  end
+
+  describe '.from_mimetype' do
+    it 'finds a type by a registered mime type' do
+      expect(AssetType.from_mimetype('image/spectest')).to eq(image)
+    end
+  end
+
+  describe '.for' do
+    it 'returns the catchall type when there is no attachment' do
+      expect(AssetType.for(nil)).to eq(AssetType.catchall)
+    end
+  end
+
+  describe '.catchall' do
+    it 'is the :other type' do
+      expect(AssetType.catchall).to eq(AssetType.find(:other))
+    end
+  end
+
+  describe '.all and .known_types' do
+    it 'includes registered types' do
+      expect(AssetType.known_types).to include(:spec_image)
+      expect(AssetType.all).to include(image)
+    end
+  end
+
+  describe '.known_mimetypes' do
+    it 'includes registered mime types' do
+      expect(AssetType.known_mimetypes).to include('image/spectest')
+    end
+  end
+
+  describe '.mime_types_for' do
+    it 'returns the mime types for the named types' do
+      expect(AssetType.mime_types_for(:spec_image)).to eq(%w[image/spectest])
+    end
+  end
+
+  describe '.slice' do
+    it 'returns the named types' do
+      expect(AssetType.slice(:spec_image)).to eq([image])
+    end
+  end
+end

data/spec/models/file_not_found_page_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe FileNotFoundPage do
+  subject(:page) { FileNotFoundPage.new }
+
+  it 'is a Page' do
+    expect(page).to be_a(Page)
+  end
+
+  describe '#cache_timeout' do
+    it 'is five minutes' do
+      expect(page.cache_timeout).to eq(5.minutes)
+    end
+  end
+
+  describe '#allowed_children' do
+    it 'has none' do
+      expect(page.allowed_children).to eq([])
+    end
+  end
+
+  describe '#virtual?' do
+    it 'is true' do
+      expect(page.virtual?).to be(true)
+    end
+  end
+
+  describe '#response_code' do
+    it 'is 404' do
+      expect(page.response_code).to eq(404)
+    end
+  end
+end

data/spec/models/haml_filter_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe HamlFilter do
+  subject(:filter) { HamlFilter.new }
+
+  it 'is a TextFilter' do
+    expect(filter).to be_a(TextFilter)
+  end
+
+  describe '.filter_name' do
+    it 'is derived from the class name' do
+      expect(HamlFilter.filter_name).to eq('Haml')
+    end
+  end
+
+  describe '#filter' do
+    it 'renders Haml markup to HTML' do
+      expect(filter.filter('%p Hello world')).to eq("<p>Hello world</p>\n")
+    end
+
+    it 'un-escapes radius tags that Haml would otherwise escape' do
+      # Haml escapes the `=` output to &lt;r:title /&gt;; the filter restores it.
+      expect(filter.filter('= "<r:title />"')).to eq("<r:title/>\n")
+    end
+
+    it 'leaves radius tags in plain text intact' do
+      expect(filter.filter("%p\n  <r:title />")).to eq("<p>\n<r:title />\n</p>\n")
+    end
+  end
+end

data/spec/models/menu_renderer_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe MenuRenderer do
+  # MenuRenderer is extended onto a Page instance (see Admin::NodeHelper).
+  let(:page) { Page.new.tap { |p| p.extend(MenuRenderer) } }
+
+  # MenuRenderer keeps its exclusion list in a module-level ivar. Isolate it so
+  # the .exclude example doesn't leak into others regardless of run order.
+  before(:all) { @orig_excluded = MenuRenderer.instance_variable_get(:@excluded_class_names) }
+  after(:all)  { MenuRenderer.instance_variable_set(:@excluded_class_names, @orig_excluded) }
+  before       { MenuRenderer.instance_variable_set(:@excluded_class_names, []) }
+
+  describe '#view' do
+    it 'reads back an assigned view' do
+      view = Object.new
+      page.view = view
+      expect(page.view).to eq(view)
+    end
+  end
+
+  describe '#menu_renderer_module_name' do
+    it 'is MenuRenderer for a plain page' do
+      expect(page.menu_renderer_module_name).to eq('MenuRenderer')
+    end
+  end
+
+  describe '#additional_menu_features?' do
+    it 'is false when no page-specific renderer module exists' do
+      expect(page.additional_menu_features?).to be_falsey
+    end
+  end
+
+  describe '#allowed_child_classes' do
+    it 'constantizes the names from the allowed-children cache' do
+      page.allowed_children_cache = 'Page,FileNotFoundPage'
+      expect(page.allowed_child_classes).to eq([Page, FileNotFoundPage])
+    end
+
+    it 'skips names that cannot be constantized' do
+      page.allowed_children_cache = 'Page,NotARealClassName'
+      expect(page.allowed_child_classes).to eq([Page])
+    end
+
+    it 'excludes names registered via .exclude' do
+      MenuRenderer.exclude('FileNotFoundPage')
+      page.allowed_children_cache = 'Page,FileNotFoundPage'
+      expect(page.allowed_child_classes).to eq([Page])
+      expect(MenuRenderer.excluded_class_names).to include('FileNotFoundPage')
+    end
+  end
+
+  describe '#add_child_disabled?' do
+    it 'is true when there are no allowed child classes' do
+      page.allowed_children_cache = ''
+      expect(page.add_child_disabled?).to be(true)
+    end
+
+    it 'is false when there is at least one allowed child class' do
+      page.allowed_children_cache = 'Page'
+      expect(page.add_child_disabled?).to be(false)
+    end
+  end
+end

data/spec/models/page_attachment_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe PageAttachment do
+  describe '#selected?' do
+    it 'is false by default' do
+      expect(PageAttachment.new.selected?).to be(false)
+    end
+
+    it 'is true when selected is set to a truthy value' do
+      attachment = PageAttachment.new
+      attachment.selected = '1'
+      expect(attachment.selected?).to be(true)
+    end
+
+    it 'is false when selected is set to nil' do
+      attachment = PageAttachment.new
+      attachment.selected = nil
+      expect(attachment.selected?).to be(false)
+    end
+  end
+
+  describe '#add_to_list_bottom' do
+    it 'keeps an already-assigned position' do
+      attachment = PageAttachment.new(position: 5)
+      attachment.add_to_list_bottom
+      expect(attachment.position).to eq(5)
+    end
+  end
+end

data/spec/models/page_context_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe PageContext do
+  let(:page) { FactoryBot.build(:page, title: 'My Page') }
+  let(:context) { PageContext.new(page) }
+
+  describe '#initialize' do
+    it 'exposes the page it was built for' do
+      expect(context.page).to eq(page)
+    end
+
+    it 'registers the page as a global' do
+      expect(context.globals.page).to eq(page)
+    end
+
+    it 'defines a tag for each of the page tags' do
+      expect(context.definitions.keys).to include('title')
+    end
+  end
+
+  describe '#dup' do
+    it 'returns an independent PageContext for the same page' do
+      copy = context.dup
+      expect(copy).to be_a(PageContext)
+      expect(copy).not_to equal(context)
+      expect(copy.page).to eq(page)
+      expect(copy.globals.page).to eq(page)
+    end
+
+    it 'copies the definitions rather than sharing them' do
+      copy = context.dup
+      expect(copy.definitions).not_to equal(context.definitions)
+      expect(copy.definitions.keys).to eq(context.definitions.keys)
+    end
+  end
+
+  describe 'rendering through Page#parse' do
+    it 'renders a standard tag' do
+      expect(page.send(:parse, '<r:title />')).to eq('My Page')
+    end
+
+    context 'when a tag raises and errors are suppressed (production-like)' do
+      before { allow_any_instance_of(PageContext).to receive(:raise_errors?).and_return(false) }
+
+      it 'renders the error message inside a div' do
+        output = page.send(:parse, '<r:find />')
+        expect(output).to match(%r{<div><strong>.*find.*</strong></div>})
+      end
+    end
+
+    context 'when errors are raised (development/test)' do
+      it 'propagates the exception' do
+        expect { page.send(:parse, '<r:find />') }.to raise_error(StandardTags::TagError)
+      end
+    end
+  end
+end

data/spec/models/page_field_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe PageField do
+  describe 'validations' do
+    it 'requires a name' do
+      field = PageField.new(content: 'value')
+      expect(field).not_to be_valid
+      expect(field.errors[:name]).to be_present
+    end
+
+    it 'is valid with a name' do
+      expect(PageField.new(name: 'keywords', content: 'value')).to be_valid
+    end
+  end
+end