- ')
+ expect(html).to include('
- Item 1 ') + expect(html).to include(']+>/) + expect(plain).to include('Hello') + expect(plain).to include('World') + end + end + + context 'with complex markdown' do + let(:markdown) do + <<~MD + # Title + + This is **bold** and *italic*. + + - Item 1 + - Item 2 + + [Link](https://example.com) + + ```ruby + code + ``` + MD + end + + it 'extracts all text content' do + plain = helper.render_markdown_plain(markdown) + + expect(plain).to include('Title') + expect(plain).to include('bold') + expect(plain).to include('italic') + expect(plain).to include('Item 1') + expect(plain).to include('Item 2') + end + + it 'removes all HTML tags' do + plain = helper.render_markdown_plain(markdown) + + expect(plain).not_to match(/<[^>]+>/) + end + + it 'includes code content as text' do + plain = helper.render_markdown_plain(markdown) + + expect(plain).to include('code') + end + end + + context 'with custom options' do + it 'accepts custom rendering options' do + plain = helper.render_markdown_plain('# Test', hard_wrap: false) + + expect(plain).to be_a(String) + expect(plain).to include('Test') + end + + it 'passes options to MarkdownRendererService' do + expect(MarkdownRendererService).to receive(:new) + .with('# Test', { hard_wrap: false }) + .and_call_original + + helper.render_markdown_plain('# Test', hard_wrap: false) + end + end + + context 'with empty or nil input' do + it 'returns empty string for nil' do + expect(helper.render_markdown_plain(nil)).to eq('') + end + + it 'returns empty string for empty string' do + expect(helper.render_markdown_plain('')).to eq('') + end + + it 'returns empty string for whitespace-only string' do + expect(helper.render_markdown_plain(' ')).to eq('') + end + end + end + + describe 'integration with views' do + it 'can be used in views' do + # Simulate view usage + html = helper.render_markdown('# View Test') + + expect(html).to be_html_safe + expect(html).to include('View Test') + end + + it 'can render file content in views' do + file_path = Rails.root.join('spec/fixtures/files/view_test.md') + FileUtils.mkdir_p(File.dirname(file_path)) + File.write(file_path, '# View File Test') + + html = helper.render_markdown_file('spec/fixtures/files/view_test.md') + + expect(html).to include('View File Test') + + FileUtils.rm_f(file_path) + end + end + end +end diff --git a/spec/helpers/better_together/sidebar_nav_helper_spec.rb b/spec/helpers/better_together/sidebar_nav_helper_spec.rb new file mode 100644 index 000000000..69b5dfbc5 --- /dev/null +++ b/spec/helpers/better_together/sidebar_nav_helper_spec.rb @@ -0,0 +1,359 @@ +# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe BetterTogether::SidebarNavHelper do + # Include engine routes for path helpers + include BetterTogether::Engine.routes.url_helpers + + let(:community) { BetterTogether::Platform.host.first.community } + let(:nav) { create(:better_together_navigation_area, navigable: community) } + let(:parent_page) { create(:better_together_page, slug: 'parent-page', protected: false) } + let(:child_page) { create(:better_together_page, slug: 'child-page', protected: false) } + let(:grandchild_page) { create(:better_together_page, slug: 'grandchild-page', protected: false) } + let(:current_page) { parent_page } + + before do + configure_host_platform + + # Define render_page_path helper for specs (it's a catch-all route) + def helper.render_page_path(slug) + "/#{slug}" + end + + # Trigger lazy evaluation of nav (which creates community) + nav + + # Clear cache before each test + Rails.cache.clear + end + + describe '#render_sidebar_nav' do + context 'with no navigation items' do + it 'renders empty accordion structure' do + result = helper.render_sidebar_nav(nav:, current_page:) + + expect(result).to have_css('div.accordion#sidebar_nav_accordion') + expect(result).not_to have_css('.accordion-item') + end + end + + context 'with single top-level item' do + let!(:nav_item) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: parent_page, + position: 1, + parent_id: nil) + end + + it 'renders the navigation item' do + result = helper.render_sidebar_nav(nav:, current_page:) + + expect(result).to have_css('.accordion-item') + expect(result).to have_link(nav_item.title) + end + + it 'marks current page as active' do + result = helper.render_sidebar_nav(nav:, current_page: parent_page) + + expect(result).to have_css('a.btn-sidebar-nav.active') + end + + it 'does not mark other pages as active' do + result = helper.render_sidebar_nav(nav:, current_page: child_page) + + expect(result).to have_css('a.btn-sidebar-nav.collapsed') + expect(result).not_to have_css('a.btn-sidebar-nav.active') + end + end + + context 'with hierarchical navigation items' do + let!(:parent_nav_item) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: parent_page, + position: 1, + parent_id: nil) + end + + let!(:child_nav_item) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: child_page, + position: 1, + parent_id: parent_nav_item.id) + end + + let!(:grandchild_nav_item) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: grandchild_page, + position: 1, + parent_id: child_nav_item.id) + end + + it 'renders nested accordion structure' do + result = helper.render_sidebar_nav(nav:, current_page:) + + expect(result).to have_css('.accordion-item.level-0') + expect(result).to have_css('.accordion-item.level-1') + expect(result).to have_css('.accordion-item.level-2') + end + + it 'includes collapse toggle for items with children' do + result = helper.render_sidebar_nav(nav:, current_page:) + + expect(result).to have_css('a.sidebar-level-toggle[data-bs-toggle="collapse"]') + end + + it 'expands parent when child is active' do + result = helper.render_sidebar_nav(nav:, current_page: child_page) + doc = Nokogiri::HTML(result) + + collapse_div = doc.css("#collapse_#{parent_nav_item.id}").first + expect(collapse_div['class']).to include('show') + end + + it 'expands ancestors when grandchild is active' do + result = helper.render_sidebar_nav(nav:, current_page: grandchild_page) + doc = Nokogiri::HTML(result) + + parent_collapse = doc.css("#collapse_#{parent_nav_item.id}").first + child_collapse = doc.css("#collapse_#{child_nav_item.id}").first + + expect(parent_collapse['class']).to include('show') + expect(child_collapse['class']).to include('show') + end + + it 'does not expand unrelated branches' do + other_page = create(:better_together_page, slug: 'other-page') + other_nav_item = create(:better_together_navigation_item, + navigation_area: nav, + linkable: other_page, + position: 2, + parent_id: nil) + + result = helper.render_sidebar_nav(nav:, current_page: child_page) + doc = Nokogiri::HTML(result) + + other_collapse = doc.css("#collapse_#{other_nav_item.id}").first + expect(other_collapse).to be_nil # No children, so no collapse div + end + end + + context 'with navigation items without linkable' do + let!(:nav_item_without_link) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: nil, + position: 1, + parent_id: nil) + end + + it 'renders span instead of link' do + result = helper.render_sidebar_nav(nav:, current_page:) + + expect(result).to have_css('span.non-collapsible') + expect(result).not_to have_link(nav_item_without_link.title) + end + end + + context 'caching behavior' do + let!(:nav_item) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: parent_page, + position: 1) + end + + it 'caches the rendered navigation' do + # First call should cache + first_result = helper.render_sidebar_nav(nav:, current_page:) + + # Second call should use cache + expect(Rails.cache).to receive(:fetch).and_call_original + second_result = helper.render_sidebar_nav(nav:, current_page:) + + expect(first_result).to eq(second_result) + end + + it 'uses different cache keys for different current pages' do + result1 = helper.render_sidebar_nav(nav:, current_page: parent_page) + result2 = helper.render_sidebar_nav(nav:, current_page: child_page) + + # Results should be different because active states differ + expect(result1).not_to eq(result2) + end + end + + context 'with multiple positioned items' do + let!(:first_item) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: parent_page, + position: 1, + parent_id: nil) + end + + let!(:second_item) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: child_page, + position: 2, + parent_id: nil) + end + + it 'renders items in position order' do + result = helper.render_sidebar_nav(nav:, current_page:) + doc = Nokogiri::HTML(result) + + items = doc.css('.accordion-item.level-0') + expect(items.count).to eq(2) + end + end + end + + describe '#render_nav_item' do + let!(:nav_item) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: parent_page, + position: 1, + parent_id: nil) + end + + before do + # Set up instance variables that render_nav_item expects + nav_items = nav.navigation_items.positioned.includes(:string_translations, linkable: %i[string_translations]) + helper.instance_variable_set(:@nav_item_cache, nav_items.index_by(&:id)) + helper.instance_variable_set(:@nav_item_children, nav_items.group_by(&:parent_id)) + end + + it 'renders accordion item with correct level class' do + result = helper.render_nav_item( + nav_item:, + current_page:, + level: 0, + parent_id: 'sidebar_nav_accordion', + index: 0 + ) + + expect(result).to have_css('.accordion-item.level-0') + end + + it 'uses h3 for level 0' do + result = helper.render_nav_item( + nav_item:, + current_page:, + level: 0, + parent_id: 'sidebar_nav_accordion', + index: 0 + ) + + expect(result).to have_css('h3.accordion-header') + end + + it 'uses h4 for level 1' do + child_nav_item = create(:better_together_navigation_item, + navigation_area: nav, + linkable: child_page, + parent_id: nav_item.id, + position: 1) + + # Refresh instance variables + nav_items = nav.navigation_items.positioned.includes(:string_translations, linkable: %i[string_translations]) + helper.instance_variable_set(:@nav_item_cache, nav_items.index_by(&:id)) + helper.instance_variable_set(:@nav_item_children, nav_items.group_by(&:parent_id)) + + result = helper.render_nav_item( + nav_item: child_nav_item, + current_page:, + level: 1, + parent_id: "collapse_#{nav_item.id}", + index: 0 + ) + + expect(result).to have_css('h4.accordion-header') + end + + it 'limits heading level to h6 for deep nesting' do + deep_item = create(:better_together_navigation_item, + navigation_area: nav, + linkable: parent_page, + position: 1) + + nav_items = nav.navigation_items.positioned.includes(:string_translations, linkable: %i[string_translations]) + helper.instance_variable_set(:@nav_item_cache, nav_items.index_by(&:id)) + helper.instance_variable_set(:@nav_item_children, nav_items.group_by(&:parent_id)) + + result = helper.render_nav_item( + nav_item: deep_item, + current_page:, + level: 10, + parent_id: 'parent', + index: 0 + ) + + expect(result).to have_css('h6.accordion-header') + end + end + + describe '#has_active_descendants?' do + let!(:parent_nav_item) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: parent_page, + position: 1, + parent_id: nil) + end + + let!(:child_nav_item) do + create(:better_together_navigation_item, + navigation_area: nav, + linkable: child_page, + position: 1, + parent_id: parent_nav_item.id) + end + + before do + nav_items = nav.navigation_items.positioned.includes(:string_translations, linkable: %i[string_translations]) + helper.instance_variable_set(:@nav_item_children, nav_items.group_by(&:parent_id)) + end + + it 'returns true when child is the current page' do + result = helper.has_active_descendants?(parent_nav_item.id, child_page) + + expect(result).to be true + end + + it 'returns false when no descendants are active' do + other_page = create(:better_together_page, slug: 'other') + result = helper.has_active_descendants?(parent_nav_item.id, other_page) + + expect(result).to be false + end + + it 'returns false when nav item has no children' do + result = helper.has_active_descendants?(child_nav_item.id, parent_page) + + expect(result).to be false + end + + it 'memoizes results for performance' do + helper.has_active_descendants?(parent_nav_item.id, child_page) + + cache = helper.instance_variable_get(:@active_descendant_cache) + expect(cache).to have_key(parent_nav_item.id) + end + + it 'returns cached result on subsequent calls' do + first_result = helper.has_active_descendants?(parent_nav_item.id, child_page) + + # This should use cached value + second_result = helper.has_active_descendants?(parent_nav_item.id, child_page) + + expect(first_result).to eq(second_result) + end + end +end diff --git a/spec/jobs/better_together/metrics/track_download_job_spec.rb b/spec/jobs/better_together/metrics/track_download_job_spec.rb index 8d78829da..16d4d6bde 100644 --- a/spec/jobs/better_together/metrics/track_download_job_spec.rb +++ b/spec/jobs/better_together/metrics/track_download_job_spec.rb @@ -2,10 +2,64 @@ require 'rails_helper' -module BetterTogether - RSpec.describe Metrics::TrackDownloadJob do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be +RSpec.describe BetterTogether::Metrics::TrackDownloadJob do + describe '#perform' do + let(:page) { create(:page) } + let(:file_name) { 'document.pdf' } + let(:file_type) { 'application/pdf' } + let(:file_size) { 1024 } + let(:locale) { 'en' } + + it 'creates a Download record' do + expect do + described_class.new.perform(page, file_name, file_type, file_size, locale) + end.to change(BetterTogether::Metrics::Download, :count).by(1) + end + + it 'sets the downloadable correctly' do + described_class.new.perform(page, file_name, file_type, file_size, locale) + download = BetterTogether::Metrics::Download.last + expect(download.downloadable).to eq(page) + end + + it 'sets the file_name correctly' do + described_class.new.perform(page, file_name, file_type, file_size, locale) + download = BetterTogether::Metrics::Download.last + expect(download.file_name).to eq(file_name) + end + + it 'sets the file_type correctly' do + described_class.new.perform(page, file_name, file_type, file_size, locale) + download = BetterTogether::Metrics::Download.last + expect(download.file_type).to eq(file_type) + end + + it 'sets the file_size correctly' do + described_class.new.perform(page, file_name, file_type, file_size, locale) + download = BetterTogether::Metrics::Download.last + expect(download.file_size).to eq(file_size) + end + + it 'sets the locale correctly' do + described_class.new.perform(page, file_name, file_type, file_size, locale) + download = BetterTogether::Metrics::Download.last + expect(download.locale).to eq(locale) + end + + it 'sets downloaded_at to current time' do + described_class.new.perform(page, file_name, file_type, file_size, locale) + download = BetterTogether::Metrics::Download.last + expect(download.downloaded_at).to be_within(1.second).of(Time.current) + end + + it 'enqueues the job' do + expect do + described_class.perform_later(page, file_name, file_type, file_size, locale) + end.to have_enqueued_job(described_class).with(page, file_name, file_type, file_size, locale) + end + + it 'uses the metrics queue' do + expect(described_class.new.queue_name).to eq('metrics') end end end diff --git a/spec/jobs/better_together/metrics/track_link_click_job_spec.rb b/spec/jobs/better_together/metrics/track_link_click_job_spec.rb index 294ba6891..40d58832e 100644 --- a/spec/jobs/better_together/metrics/track_link_click_job_spec.rb +++ b/spec/jobs/better_together/metrics/track_link_click_job_spec.rb @@ -2,10 +2,57 @@ require 'rails_helper' -module BetterTogether - RSpec.describe Metrics::TrackLinkClickJob do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be +RSpec.describe BetterTogether::Metrics::TrackLinkClickJob do + describe '#perform' do + let(:url) { 'https://example.com' } + let(:page_url) { 'https://mysite.com/page' } + let(:locale) { 'en' } + let(:internal) { false } + + it 'creates a LinkClick record' do + expect do + described_class.new.perform(url, page_url, locale, internal) + end.to change(BetterTogether::Metrics::LinkClick, :count).by(1) + end + + it 'sets the url correctly' do + described_class.new.perform(url, page_url, locale, internal) + link_click = BetterTogether::Metrics::LinkClick.last + expect(link_click.url).to eq(url) + end + + it 'sets the page_url correctly' do + described_class.new.perform(url, page_url, locale, internal) + link_click = BetterTogether::Metrics::LinkClick.last + expect(link_click.page_url).to eq(page_url) + end + + it 'sets the locale correctly' do + described_class.new.perform(url, page_url, locale, internal) + link_click = BetterTogether::Metrics::LinkClick.last + expect(link_click.locale).to eq(locale) + end + + it 'sets the internal flag correctly' do + described_class.new.perform(url, page_url, locale, true) + link_click = BetterTogether::Metrics::LinkClick.last + expect(link_click.internal).to be true + end + + it 'sets clicked_at to current time' do + described_class.new.perform(url, page_url, locale, internal) + link_click = BetterTogether::Metrics::LinkClick.last + expect(link_click.clicked_at).to be_within(1.second).of(Time.current) + end + + it 'enqueues the job' do + expect do + described_class.perform_later(url, page_url, locale, internal) + end.to have_enqueued_job(described_class).with(url, page_url, locale, internal) + end + + it 'uses the metrics queue' do + expect(described_class.new.queue_name).to eq('metrics') end end end diff --git a/spec/jobs/better_together/metrics/track_page_view_job_spec.rb b/spec/jobs/better_together/metrics/track_page_view_job_spec.rb index 3b95d0743..7eaf4f8ea 100644 --- a/spec/jobs/better_together/metrics/track_page_view_job_spec.rb +++ b/spec/jobs/better_together/metrics/track_page_view_job_spec.rb @@ -2,10 +2,43 @@ require 'rails_helper' -module BetterTogether - RSpec.describe Metrics::TrackPageViewJob do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be +RSpec.describe BetterTogether::Metrics::TrackPageViewJob do + describe '#perform' do + let(:page) { create(:page) } + let(:locale) { 'en' } + + it 'creates a PageView record' do + expect do + described_class.new.perform(page, locale) + end.to change(BetterTogether::Metrics::PageView, :count).by(1) + end + + it 'sets the pageable correctly' do + described_class.new.perform(page, locale) + page_view = BetterTogether::Metrics::PageView.last + expect(page_view.pageable).to eq(page) + end + + it 'sets the locale correctly' do + described_class.new.perform(page, locale) + page_view = BetterTogether::Metrics::PageView.last + expect(page_view.locale).to eq(locale) + end + + it 'sets viewed_at to current time' do + described_class.new.perform(page, locale) + page_view = BetterTogether::Metrics::PageView.last + expect(page_view.viewed_at).to be_within(1.second).of(Time.current) + end + + it 'enqueues the job' do + expect do + described_class.perform_later(page, locale) + end.to have_enqueued_job(described_class).with(page, locale) + end + + it 'uses the metrics queue' do + expect(described_class.new.queue_name).to eq('metrics') end end end diff --git a/spec/jobs/better_together/metrics/track_share_job_spec.rb b/spec/jobs/better_together/metrics/track_share_job_spec.rb index 79e556a20..be5262b1b 100644 --- a/spec/jobs/better_together/metrics/track_share_job_spec.rb +++ b/spec/jobs/better_together/metrics/track_share_job_spec.rb @@ -2,10 +2,76 @@ require 'rails_helper' -module BetterTogether - RSpec.describe Metrics::TrackShareJob do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be +RSpec.describe BetterTogether::Metrics::TrackShareJob do + describe '#perform' do + let(:platform) { 'facebook' } + let(:url) { 'https://example.com' } + let(:locale) { 'en' } + + context 'without shareable' do + it 'creates a Share record without shareable' do + expect do + described_class.new.perform(platform, url, locale, nil, nil) + end.to change(BetterTogether::Metrics::Share, :count).by(1) + end + + it 'sets the platform correctly' do + described_class.new.perform(platform, url, locale, nil, nil) + share = BetterTogether::Metrics::Share.last + expect(share.platform).to eq(platform) + end + + it 'sets the url correctly' do + described_class.new.perform(platform, url, locale, nil, nil) + share = BetterTogether::Metrics::Share.last + expect(share.url).to eq(url) + end + + it 'sets the locale correctly' do + described_class.new.perform(platform, url, locale, nil, nil) + share = BetterTogether::Metrics::Share.last + expect(share.locale).to eq(locale) + end + + it 'sets shared_at to current time' do + described_class.new.perform(platform, url, locale, nil, nil) + share = BetterTogether::Metrics::Share.last + expect(share.shared_at).to be_within(1.second).of(Time.current) + end + end + + context 'with allowed shareable' do + let(:page) { create(:page) } + + it 'creates a Share record with shareable' do + expect do + described_class.new.perform(platform, url, locale, 'BetterTogether::Page', page.id) + end.to change(BetterTogether::Metrics::Share, :count).by(1) + end + + it 'associates the shareable correctly' do + described_class.new.perform(platform, url, locale, 'BetterTogether::Page', page.id) + share = BetterTogether::Metrics::Share.last + expect(share.shareable).to eq(page) + end + end + + context 'with disallowed shareable type' do + it 'does not create a Share record' do + expect do + described_class.new.perform(platform, url, locale, 'BetterTogether::Person', '123') + end.not_to change(BetterTogether::Metrics::Share, :count) + end + end + + it 'enqueues the job' do + expect do + described_class.perform_later(platform, url, locale, nil, nil) + end.to have_enqueued_job(described_class).with(platform, url, locale, nil, nil) + end + + it 'uses the metrics queue' do + expect(described_class.new.queue_name).to eq('metrics') end end end diff --git a/spec/jobs/better_together/platform_invitation_mailer_job_spec.rb b/spec/jobs/better_together/platform_invitation_mailer_job_spec.rb new file mode 100644 index 000000000..d84e90f73 --- /dev/null +++ b/spec/jobs/better_together/platform_invitation_mailer_job_spec.rb @@ -0,0 +1,232 @@ +# frozen_string_literal: true + +require 'rails_helper' + +# rubocop:disable Metrics/ModuleLength +module BetterTogether + RSpec.describe PlatformInvitationMailerJob do + include ActiveSupport::Testing::TimeHelpers + + describe '#perform' do + let(:platform) do + create(:platform, + name: 'Test Platform', + time_zone: 'America/New_York') + end + let(:platform_invitation) do + create(:platform_invitation, + invitable: platform, + invitee_email: 'invitee@example.com', + greeting: 'Welcome!', + locale: 'en', + valid_from: 1.day.ago, + valid_until: 1.day.from_now) + end + + context 'when invitation is within valid period' do + it 'sends the invitation email' do + expect do + described_class.new.perform(platform_invitation.id) + end.to change { ActionMailer::Base.deliveries.count }.by(1) + + mail = ActionMailer::Base.deliveries.last + expect(mail.to).to include(platform_invitation.invitee_email) + end + + it 'updates last_sent timestamp' do + freeze_time do + described_class.new.perform(platform_invitation.id) + platform_invitation.reload + expect(platform_invitation.last_sent).to be_within(1.second).of(Time.current) + end + end + + it 'uses platform time zone for time comparisons' do + allow(Time).to receive(:use_zone).and_call_original + expect(Time).to receive(:use_zone).with(platform.time_zone) + described_class.new.perform(platform_invitation.id) + end + + it 'uses invitation locale for email' do + allow(I18n).to receive(:with_locale).and_call_original + expect(I18n).to receive(:with_locale).with(platform_invitation.locale.to_sym) + described_class.new.perform(platform_invitation.id) + end + end + + context 'when invitation is before valid_from date' do + let(:platform_invitation) do + create(:platform_invitation, + invitable: platform, + invitee_email: 'invitee@example.com', + locale: 'en', + valid_from: 1.day.from_now, + valid_until: 2.days.from_now) + end + + it 'does not send the email' do + expect do + described_class.new.perform(platform_invitation.id) + end.not_to have_enqueued_mail(PlatformInvitationMailer, :invite) + end + + it 'does not update last_sent timestamp' do + original_last_sent = platform_invitation.last_sent + described_class.new.perform(platform_invitation.id) + platform_invitation.reload + expect(platform_invitation.last_sent).to eq(original_last_sent) + end + + it 'logs info message' do + allow(Rails.logger).to receive(:info) + described_class.new.perform(platform_invitation.id) + expect(Rails.logger).to have_received(:info) + .with(/Invitation .* is not within the valid period/) + end + end + + context 'when invitation is after valid_until date' do + let(:platform_invitation) do + create(:platform_invitation, + invitable: platform, + invitee_email: 'invitee@example.com', + locale: 'en', + valid_from: 3.days.ago, + valid_until: 1.day.ago) + end + + it 'does not send the email' do + expect do + described_class.new.perform(platform_invitation.id) + end.not_to have_enqueued_mail(PlatformInvitationMailer, :invite) + end + + it 'does not update last_sent timestamp' do + original_last_sent = platform_invitation.last_sent + described_class.new.perform(platform_invitation.id) + platform_invitation.reload + expect(platform_invitation.last_sent).to eq(original_last_sent) + end + end + + context 'when valid_until is nil (no expiration)' do + let(:platform_invitation) do + create(:platform_invitation, + invitable: platform, + invitee_email: 'invitee@example.com', + locale: 'en', + valid_from: 1.day.ago, + valid_until: nil) + end + + it 'sends the email' do + expect do + described_class.new.perform(platform_invitation.id) + end.to change { ActionMailer::Base.deliveries.count }.by(1) + end + + it 'updates last_sent timestamp' do + freeze_time do + described_class.new.perform(platform_invitation.id) + platform_invitation.reload + expect(platform_invitation.last_sent).to be_within(1.second).of(Time.current) + end + end + end + + context 'with different time zones' do + let(:tokyo_platform) do + create(:platform, + name: 'Tokyo Platform', + time_zone: 'Asia/Tokyo') + end + let(:tokyo_invitation) do + create(:platform_invitation, + invitable: tokyo_platform, + invitee_email: 'tokyo@example.com', + locale: 'en', + valid_from: 1.day.ago, + valid_until: 1.day.from_now) + end + + it 'respects platform time zone' do + allow(Time).to receive(:use_zone).and_call_original + expect(Time).to receive(:use_zone).with('Asia/Tokyo') + described_class.new.perform(tokyo_invitation.id) + end + + it 'sets last_sent in platform time zone' do + freeze_time do + described_class.new.perform(tokyo_invitation.id) + tokyo_invitation.reload + expect(tokyo_invitation.last_sent).to be_present + end + end + end + + context 'with different locales' do + let(:spanish_invitation) do + create(:platform_invitation, + invitable: platform, + invitee_email: 'spanish@example.com', + locale: 'es', + valid_from: 1.day.ago, + valid_until: 1.day.from_now) + end + + it 'uses invitation locale' do + allow(I18n).to receive(:with_locale).and_call_original + expect(I18n).to receive(:with_locale).with(:es) + described_class.new.perform(spanish_invitation.id) + end + end + + describe 'retry behavior' do + it 'retries on Net::OpenTimeout' do + allow(BetterTogether::PlatformInvitationMailer).to receive(:invite) + .and_raise(Net::OpenTimeout) + + # Attempting to perform should raise the error (which ActiveJob will then retry) + expect do + described_class.new.perform(platform_invitation.id) + end.to raise_error(Net::OpenTimeout) + end + end + + context 'when platform invitation not found' do + it 'raises ActiveRecord::RecordNotFound' do + expect do + described_class.new.perform('nonexistent-id') + end.to raise_error(ActiveRecord::RecordNotFound) + end + end + + describe 'time zone edge cases' do + it 'handles timezone boundaries correctly' do + # Create invitation that is valid at current time in platform timezone + # but might not be in UTC + Time.use_zone(platform.time_zone) do + current_time = Time.zone.now + invitation = create(:platform_invitation, + invitable: platform, + invitee_email: 'edge@example.com', + locale: 'en', + valid_from: current_time - 1.hour, + valid_until: current_time + 1.hour) + + expect do + described_class.new.perform(invitation.id) + end.to change { ActionMailer::Base.deliveries.count }.by(1) + end + end + end + + describe 'job queue' do + it 'uses mailer queue' do + expect(described_class.new.queue_name).to eq('mailers') + end + end + end + end +end +# rubocop:enable Metrics/ModuleLength diff --git a/spec/lib/better_together/configuration_spec.rb b/spec/lib/better_together/configuration_spec.rb new file mode 100644 index 000000000..6b699b0ef --- /dev/null +++ b/spec/lib/better_together/configuration_spec.rb @@ -0,0 +1,111 @@ +# frozen_string_literal: true + +require 'rails_helper' + +# Explicitly load the configuration file since it may not be autoloaded +require_relative '../../../lib/better_together/configuration' + +RSpec.describe BetterTogether::Configuration do + subject(:configuration) { described_class.new } + + describe 'attribute readers' do + it { is_expected.to respond_to(:base_url) } + it { is_expected.to respond_to(:new_user_password_path) } + it { is_expected.to respond_to(:user_class) } + it { is_expected.to respond_to(:user_confirmation_path) } + end + + describe 'delegation to BetterTogether module' do + describe '#base_url=' do + it 'delegates to BetterTogether.base_url=' do + expect(BetterTogether).to receive(:base_url=).with('http://example.com') + configuration.base_url = 'http://example.com' + end + + it 'allows setting base_url' do + configuration.base_url = 'http://test.com' + expect(BetterTogether.base_url).to eq('http://test.com') + end + end + + describe '#new_user_password_path=' do + it 'delegates to BetterTogether.new_user_password_path=' do + expect(BetterTogether).to receive(:new_user_password_path=).with('/reset') + configuration.new_user_password_path = '/reset' + end + + it 'allows setting new_user_password_path' do + configuration.new_user_password_path = '/custom/reset' + expect(BetterTogether.new_user_password_path).to eq('/custom/reset') + end + end + + describe '#user_class=' do + it 'delegates to BetterTogether.user_class=' do + expect(BetterTogether).to receive(:user_class=).with('CustomUser') + configuration.user_class = 'CustomUser' + end + + it 'allows setting user_class' do + configuration.user_class = '::BetterTogether::User' + expect(BetterTogether.user_class).to eq(BetterTogether::User) + end + end + + describe '#user_confirmation_path=' do + it 'delegates to BetterTogether.user_confirmation_path=' do + expect(BetterTogether).to receive(:user_confirmation_path=).with('/confirm') + configuration.user_confirmation_path = '/confirm' + end + + it 'allows setting user_confirmation_path' do + configuration.user_confirmation_path = '/custom/confirm' + expect(BetterTogether.user_confirmation_path).to eq('/custom/confirm') + end + end + end + + describe 'configuration pattern' do + it 'can be used in a block configuration style' do + config = described_class.new + + config.base_url = 'http://configured.com' + config.user_class = '::BetterTogether::User' + + expect(BetterTogether.base_url).to eq('http://configured.com') + expect(BetterTogether.user_class).to eq(BetterTogether::User) + end + + it 'maintains configuration state across instances' do + config1 = described_class.new + config1.base_url = 'http://first.com' + + described_class.new + expect(BetterTogether.base_url).to eq('http://first.com') + end + end + + describe 'integration with BetterTogether module' do + before do + # Reset configuration + BetterTogether.base_url = nil + BetterTogether.user_class = nil + BetterTogether.new_user_password_path = nil + BetterTogether.user_confirmation_path = nil + end + + it 'allows full configuration setup' do + config = described_class.new + + config.base_url = 'http://example.com' + config.user_class = '::BetterTogether::User' + config.new_user_password_path = '/passwords/new' + config.user_confirmation_path = '/users/confirmation' + + expect(BetterTogether.base_url).to eq('http://example.com') + expect(BetterTogether.user_class).to eq(BetterTogether::User) + expect(BetterTogether.new_user_password_path).to eq('/passwords/new') + expect(BetterTogether.user_confirmation_path).to eq('/users/confirmation') + end + end +end diff --git a/spec/lib/better_together/migration_helpers_spec.rb b/spec/lib/better_together/migration_helpers_spec.rb new file mode 100644 index 000000000..44e45990d --- /dev/null +++ b/spec/lib/better_together/migration_helpers_spec.rb @@ -0,0 +1,348 @@ +# frozen_string_literal: true + +require 'rails_helper' + +# rubocop:disable Metrics/ModuleLength, RSpec/StubbedMock, RSpec/VerifiedDoubles, RSpec/RepeatedExample +module BetterTogether + RSpec.describe MigrationHelpers do + # Create a test migration class to include the module + let(:migration_class) do + Class.new(ActiveRecord::Migration[7.1]) do + include BetterTogether::MigrationHelpers + end + end + + let(:migration) { migration_class.new } + + describe '#create_bt_table' do + context 'with default prefix' do + it 'creates table with better_together prefix' do + expect(migration).to receive(:create_table) + .with('better_together_test_models', id: :uuid) + .and_yield(double('TableDefinition', + integer: nil, + timestamps: nil)) + + migration.create_bt_table(:test_models) { |_t| } # rubocop:disable Lint/EmptyBlock + end + end + + context 'with custom prefix' do + it 'creates table with custom prefix' do + expect(migration).to receive(:create_table) + .with('custom_test_models', id: :uuid) + .and_yield(double('TableDefinition', + integer: nil, + timestamps: nil)) + + migration.create_bt_table(:test_models, prefix: 'custom') { |_t| } # rubocop:disable Lint/EmptyBlock + end + end + + context 'with no prefix' do + it 'creates table without prefix' do + expect(migration).to receive(:create_table) + .with('test_models', id: :uuid) + .and_yield(double('TableDefinition', + integer: nil, + timestamps: nil)) + + migration.create_bt_table(:test_models, prefix: nil) { |_t| } # rubocop:disable Lint/EmptyBlock + end + end + + context 'with false prefix' do + it 'creates table without prefix' do + expect(migration).to receive(:create_table) + .with('test_models', id: :uuid) + .and_yield(double('TableDefinition', + integer: nil, + timestamps: nil)) + + migration.create_bt_table(:test_models, prefix: false) { |_t| } # rubocop:disable Lint/EmptyBlock + end + end + + context 'with custom id type' do + it 'uses specified id type' do + expect(migration).to receive(:create_table) + .with('better_together_test_models', id: :bigint) + .and_yield(double('TableDefinition', + integer: nil, + timestamps: nil)) + + migration.create_bt_table(:test_models, id: :bigint) { |_t| } # rubocop:disable Lint/EmptyBlock + end + end + + it 'adds lock_version column' do + table_definition = double('TableDefinition') + expect(table_definition).to receive(:integer) + .with(:lock_version, null: false, default: 0) + expect(table_definition).to receive(:timestamps).with(null: false) + + expect(migration).to receive(:create_table) + .and_yield(table_definition) + + migration.create_bt_table(:test_models) { |_t| } # rubocop:disable Lint/EmptyBlock + end + + it 'adds timestamps' do + table_definition = double('TableDefinition') + expect(table_definition).to receive(:integer).with(:lock_version, null: false, default: 0) + expect(table_definition).to receive(:timestamps).with(null: false) + + expect(migration).to receive(:create_table) + .and_yield(table_definition) + + migration.create_bt_table(:test_models) { |_t| } # rubocop:disable Lint/EmptyBlock + end + + it 'yields block for additional columns' do + block_called = false + table_definition = double('TableDefinition', + integer: nil, + timestamps: nil) + + expect(migration).to receive(:create_table) + .and_yield(table_definition) + + migration.create_bt_table(:test_models) do |t| + block_called = true + expect(t).to eq(table_definition) + end + + expect(block_called).to be true + end + end + + describe '#create_bt_membership_table' do + let(:table_definition) do + double('TableDefinition', + bt_references: nil, + index: nil, + integer: nil, + timestamps: nil) + end + + before do + # Stub the create_bt_table method + allow(migration).to receive(:create_bt_table) + .and_yield(table_definition) + end + + context 'with default table names' do + it 'creates member reference with correct target table' do + expect(table_definition).to receive(:bt_references) + .with(:member, + hash_including( + null: false, + target_table: 'better_together_people' + )) + + migration.create_bt_membership_table( + :person_platform_memberships, + member_type: :person, + joinable_type: :platform + ) { |_t| } # rubocop:disable Lint/EmptyBlock + end + + it 'creates joinable reference with correct target table' do + expect(table_definition).to receive(:bt_references) + .with(:joinable, + hash_including( + null: false, + target_table: 'better_together_platforms' + )) + + migration.create_bt_membership_table( + :person_platform_memberships, + member_type: :person, + joinable_type: :platform + ) { |_t| } # rubocop:disable Lint/EmptyBlock + end + + it 'creates role reference' do + expect(table_definition).to receive(:bt_references) + .with(:role, + hash_including( + null: false, + target_table: :better_together_roles + )) + + migration.create_bt_membership_table( + :person_platform_memberships, + member_type: :person, + joinable_type: :platform + ) { |_t| } # rubocop:disable Lint/EmptyBlock + end + + it 'creates unique composite index' do + expect(table_definition).to receive(:index) + .with(%i[joinable_id member_id role_id], + hash_including( + unique: true, + name: 'unique_person_platform_membership_member_role' + )) + + migration.create_bt_membership_table( + :person_platform_memberships, + member_type: :person, + joinable_type: :platform + ) { |_t| } # rubocop:disable Lint/EmptyBlock + end + end + + context 'with custom table names' do + it 'uses custom member table name' do + expect(table_definition).to receive(:bt_references) + .with(:member, + hash_including( + target_table: 'custom_members' + )) + + migration.create_bt_membership_table( + :custom_memberships, + member_type: :user, + joinable_type: :organization, + member_table_name: 'custom_members' + ) { |_t| } # rubocop:disable Lint/EmptyBlock + end + + it 'uses custom joinable table name' do + expect(table_definition).to receive(:bt_references) + .with(:joinable, + hash_including( + target_table: 'custom_joinables' + )) + + migration.create_bt_membership_table( + :custom_memberships, + member_type: :user, + joinable_type: :organization, + joinable_table_name: 'custom_joinables' + ) { |_t| } # rubocop:disable Lint/EmptyBlock + end + end + + context 'with custom id type' do + it 'passes id type to create_bt_table' do + expect(migration).to receive(:create_bt_table) + .with(:test_memberships, hash_including(id: :bigint)) + .and_yield(table_definition) + + migration.create_bt_membership_table( + :test_memberships, + member_type: :person, + joinable_type: :platform, + id: :bigint + ) { |_t| } # rubocop:disable Lint/EmptyBlock + end + end + + it 'creates index names with proper format' do + expect(table_definition).to receive(:bt_references) + .with(:member, + hash_including( + index: { name: 'person_platform_membership_by_member' } + )) + + expect(table_definition).to receive(:bt_references) + .with(:joinable, + hash_including( + index: { name: 'person_platform_membership_by_joinable' } + )) + + expect(table_definition).to receive(:bt_references) + .with(:role, + hash_including( + index: { name: 'person_platform_membership_by_role' } + )) + + migration.create_bt_membership_table( + :person_platform_memberships, + member_type: :person, + joinable_type: :platform + ) { |_t| } # rubocop:disable Lint/EmptyBlock + end + + it 'yields block for additional columns' do + block_called = false + + migration.create_bt_membership_table( + :test_memberships, + member_type: :person, + joinable_type: :platform + ) do |t| + block_called = true + expect(t).to eq(table_definition) + end + + expect(block_called).to be true + end + end + + describe 'table naming conventions' do + it 'properly handles prefix with trailing underscore' do + expect(migration).to receive(:create_table) + .with('better_together_test_models', id: :uuid) + .and_yield(double('TableDefinition', + integer: nil, + timestamps: nil)) + + migration.create_bt_table(:test_models, prefix: 'better_together_') { |_t| } # rubocop:disable Lint/EmptyBlock + end + + it 'properly handles prefix without trailing underscore' do + expect(migration).to receive(:create_table) + .with('better_together_test_models', id: :uuid) + .and_yield(double('TableDefinition', + integer: nil, + timestamps: nil)) + + migration.create_bt_table(:test_models, prefix: 'better_together') { |_t| } # rubocop:disable Lint/EmptyBlock + end + end + + describe 'pluralization handling' do + it 'pluralizes member_type for table name' do + expect(table_definition = double('TableDefinition')).to receive(:bt_references) + .with(:member, + hash_including( + target_table: 'better_together_people' + )) + expect(table_definition).to receive(:bt_references).at_least(:once) + expect(table_definition).to receive(:index) + + allow(migration).to receive(:create_bt_table) + .and_yield(table_definition) + + migration.create_bt_membership_table( + :test_memberships, + member_type: :person, + joinable_type: :platform + ) { |_t| } # rubocop:disable Lint/EmptyBlock + end + + it 'pluralizes joinable_type for table name' do + expect(table_definition = double('TableDefinition')).to receive(:bt_references) + .with(:joinable, + hash_including( + target_table: 'better_together_platforms' + )) + expect(table_definition).to receive(:bt_references).at_least(:once) + expect(table_definition).to receive(:index) + + allow(migration).to receive(:create_bt_table) + .and_yield(table_definition) + + migration.create_bt_membership_table( + :test_memberships, + member_type: :person, + joinable_type: :platform + ) { |_t| } # rubocop:disable Lint/EmptyBlock + end + end + end +end +# rubocop:enable Metrics/ModuleLength, RSpec/StubbedMock, RSpec/VerifiedDoubles, RSpec/RepeatedExample diff --git a/spec/lib/better_together/safe_class_resolver_spec.rb b/spec/lib/better_together/safe_class_resolver_spec.rb new file mode 100644 index 000000000..13078f9c5 --- /dev/null +++ b/spec/lib/better_together/safe_class_resolver_spec.rb @@ -0,0 +1,224 @@ +# frozen_string_literal: true + +require 'rails_helper' + +# Explicitly load the file since it may not be autoloaded +require_relative '../../../lib/better_together/safe_class_resolver' + +RSpec.describe BetterTogether::SafeClassResolver do + describe '.resolve' do + context 'with nil or blank candidate' do + it 'returns nil for nil' do + expect(described_class.resolve(nil, allowed: [String])).to be_nil + end + + it 'returns nil for empty string' do + expect(described_class.resolve('', allowed: [String])).to be_nil + end + + it 'returns nil for blank string' do + expect(described_class.resolve(' ', allowed: [String])).to be_nil + end + end + + context 'with valid class in allow-list' do + it 'resolves class from string when in allow-list' do + result = described_class.resolve('String', allowed: [String]) + expect(result).to eq(String) + end + + it 'resolves class when allow-list contains class objects' do + result = described_class.resolve('String', allowed: [String, Integer]) + expect(result).to eq(String) + end + + it 'resolves class when allow-list contains string names' do + result = described_class.resolve('String', allowed: %w[String Integer]) + expect(result).to eq(String) + end + + it 'resolves namespaced class' do + result = described_class.resolve( + 'BetterTogether::User', + allowed: [BetterTogether::User] + ) + expect(result).to eq(BetterTogether::User) + end + + it 'resolves with fully qualified class name' do + result = described_class.resolve( + '::BetterTogether::User', + allowed: ['::BetterTogether::User'] + ) + expect(result).to eq(BetterTogether::User) + end + end + + context 'with class not in allow-list' do + it 'returns nil when class not in allow-list' do + result = described_class.resolve('String', allowed: [Integer]) + expect(result).to be_nil + end + + it 'returns nil when allow-list is empty' do + result = described_class.resolve('String', allowed: []) + expect(result).to be_nil + end + + it 'returns nil for malicious input' do + result = described_class.resolve('`rm -rf /`', allowed: [String]) + expect(result).to be_nil + end + end + + context 'with non-existent class name' do + it 'returns nil when class does not exist even if in allow-list' do + result = described_class.resolve('NonExistentClass', allowed: ['NonExistentClass']) + expect(result).to be_nil + end + end + + context 'security: prevents unsafe constantize' do + it 'does not allow arbitrary code execution' do + malicious_input = 'File.delete("/tmp/test")' + result = described_class.resolve(malicious_input, allowed: [String]) + expect(result).to be_nil + end + + it 'does not allow eval-like behavior' do + malicious_input = 'Kernel.system("echo hacked")' + result = described_class.resolve(malicious_input, allowed: [String]) + expect(result).to be_nil + end + + it 'only resolves exact class name matches' do + result = described_class.resolve('String#upcase', allowed: [String]) + expect(result).to be_nil + end + end + + context 'with mixed allow-list types' do + it 'handles mix of Class and String in allow-list' do + result = described_class.resolve( + 'String', + allowed: [Integer, 'String', 'Hash'] + ) + expect(result).to eq(String) + end + + it 'handles symbols converted to strings' do + result = described_class.resolve( + 'String', + allowed: [:String] + ) + expect(result).to eq(String) + end + end + end + + describe '.resolve!' do + context 'with valid class in allow-list' do + it 'returns the resolved class' do + result = described_class.resolve!('String', allowed: [String]) + expect(result).to eq(String) + end + + it 'resolves namespaced class' do + result = described_class.resolve!( + 'BetterTogether::User', + allowed: [BetterTogether::User] + ) + expect(result).to eq(BetterTogether::User) + end + end + + context 'with class not in allow-list' do + it 'raises ArgumentError by default' do + expect do + described_class.resolve!('String', allowed: [Integer]) + end.to raise_error(ArgumentError, /Disallowed class: String/) + end + + it 'raises custom error when specified' do + expect do + described_class.resolve!('String', allowed: [Integer], error_class: SecurityError) + end.to raise_error(SecurityError, /Disallowed class: String/) + end + + it 'includes the candidate in error message' do + expect do + described_class.resolve!('MaliciousClass', allowed: []) + end.to raise_error(ArgumentError, /MaliciousClass/) + end + end + + context 'with nil or blank candidate' do + it 'raises error for nil' do + expect do + described_class.resolve!(nil, allowed: [String]) + end.to raise_error(ArgumentError, /Disallowed class/) + end + + it 'raises error for empty string' do + expect do + described_class.resolve!('', allowed: [String]) + end.to raise_error(ArgumentError) + end + end + + context 'with non-existent class' do + it 'raises error when class does not exist' do + expect do + described_class.resolve!('NonExistentClass', allowed: ['NonExistentClass']) + end.to raise_error(ArgumentError, /Disallowed class: NonExistentClass/) + end + end + end + + describe 'real-world usage patterns' do + context 'polymorphic association resolution' do + it 'safely resolves polymorphic types' do + allowed_types = [ + BetterTogether::Community, + BetterTogether::Platform, + BetterTogether::Person + ] + + result = described_class.resolve( + 'BetterTogether::Community', + allowed: allowed_types + ) + expect(result).to eq(BetterTogether::Community) + + result = described_class.resolve( + 'BetterTogether::MaliciousClass', + allowed: allowed_types + ) + expect(result).to be_nil + end + end + + context 'concern inclusion validation' do + it 'validates class is in approved list before including' do + allowed_concerns = [ + 'BetterTogether::Authorable', + 'BetterTogether::Creatable' + ] + + # Valid concern + result = described_class.resolve( + 'BetterTogether::Authorable', + allowed: allowed_concerns + ) + expect(result).to be_a(Module) + + # Invalid concern + result = described_class.resolve( + 'BetterTogether::UnknownConcern', + allowed: allowed_concerns + ) + expect(result).to be_nil + end + end + end +end diff --git a/spec/mailers/better_together/authorship_mailer_spec.rb b/spec/mailers/better_together/authorship_mailer_spec.rb new file mode 100644 index 000000000..1fba9ec42 --- /dev/null +++ b/spec/mailers/better_together/authorship_mailer_spec.rb @@ -0,0 +1,165 @@ +# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe BetterTogether::AuthorshipMailer do + before do + configure_host_platform + end + + describe '#authorship_changed_notification' do + let(:page) { create(:better_together_page, title: 'Test Page') } + let(:recipient) { create(:better_together_person) } + let(:actor) { create(:better_together_person, name: 'John Doe') } + + context 'when author is added with actor name' do + let(:mail) do + described_class.with( + page:, + recipient:, + action: 'added', + actor_name: actor.name + ).authorship_changed_notification + end + + it 'renders the subject with actor name' do + expect(mail.subject).to include('Test Page') + expect(mail.subject).to include('John Doe') + end + + it 'sends to the recipient email' do + expect(mail.to).to eq([recipient.email]) + end + + it 'includes page title in body' do + expect(mail.body.encoded).to include('Test Page') + end + + it 'includes actor name in body' do + expect(mail.body.encoded).to include('John Doe') + end + + it 'is deliverable' do + expect { mail.deliver_now }.not_to raise_error + end + end + + context 'when author is added without actor name' do + let(:mail) do + described_class.with( + page:, + recipient:, + action: 'added' + ).authorship_changed_notification + end + + it 'renders the subject without actor name' do + expect(mail.subject).to include('Test Page') + end + + it 'sends to the recipient email' do + expect(mail.to).to eq([recipient.email]) + end + end + + context 'when author is removed with actor name' do + let(:mail) do + described_class.with( + page:, + recipient:, + action: 'removed', + actor_name: actor.name + ).authorship_changed_notification + end + + it 'renders the subject for removal with actor' do + expect(mail.subject).to include('Test Page') + expect(mail.subject).to include('John Doe') + end + + it 'sends to the recipient email' do + expect(mail.to).to eq([recipient.email]) + end + end + + context 'when author is removed without actor name' do + let(:mail) do + described_class.with( + page:, + recipient:, + action: 'removed' + ).authorship_changed_notification + end + + it 'renders the subject for removal without actor' do + expect(mail.subject).to include('Test Page') + end + + it 'sends to the recipient email' do + expect(mail.to).to eq([recipient.email]) + end + end + + context 'when actor_id is provided instead of actor_name' do + let(:mail) do + described_class.with( + page:, + recipient:, + action: 'added', + actor_id: actor.id + ).authorship_changed_notification + end + + it 'looks up actor by ID and includes name' do + expect(mail.subject).to include(actor.name) + end + + it 'includes actor name in body' do + expect(mail.body.encoded).to include(actor.name) + end + end + + context 'when actor_id is invalid' do + let(:mail) do + described_class.with( + page:, + recipient:, + action: 'added', + actor_id: 'nonexistent-id' + ).authorship_changed_notification + end + + it 'handles gracefully without actor name' do + expect(mail.subject).to include('Test Page') + end + end + + context 'locale handling' do + it 'respects recipient locale' do + recipient.update(locale: 'es') + mail = described_class.with( + page:, + recipient:, + action: 'added', + actor_name: actor.name + ).authorship_changed_notification + + expect(mail.body.encoded).to be_present + end + end + + context 'time zone handling' do + it 'respects recipient time zone' do + recipient.update(time_zone: 'America/New_York') + mail = described_class.with( + page:, + recipient:, + action: 'added', + actor_name: actor.name + ).authorship_changed_notification + + expect(mail.body.encoded).to be_present + end + end + end +end diff --git a/spec/mailers/better_together/platform_invitation_mailer_spec.rb b/spec/mailers/better_together/platform_invitation_mailer_spec.rb new file mode 100644 index 000000000..a6deb4376 --- /dev/null +++ b/spec/mailers/better_together/platform_invitation_mailer_spec.rb @@ -0,0 +1,187 @@ +# frozen_string_literal: true + +require 'rails_helper' + +# rubocop:disable Metrics/ModuleLength +module BetterTogether + RSpec.describe PlatformInvitationMailer do + describe '#invite' do + let(:platform) do + create(:platform, + name: 'Test Platform', + time_zone: 'America/New_York') + end + let(:platform_invitation) do + create(:platform_invitation, + invitable: platform, + invitee_email: 'invitee@example.com', + greeting: 'Welcome to our platform!', + locale: 'en', + valid_from: 1.day.ago, + valid_until: 1.day.from_now) + end + + let(:mail) { described_class.invite(platform_invitation) } + + context 'with valid invitation' do + it 'renders the subject' do + expect(mail.subject).to eq( + I18n.t('better_together.platform_invitation_mailer.invite.subject', + platform: platform.name) + ) + end + + it 'renders the receiver email' do + expect(mail.to).to eq([platform_invitation.invitee_email]) + end + + it 'renders the sender email' do + expect(mail.from).to eq(['community@bettertogethersolutions.com']) + end + + it 'assigns @platform_invitation' do + expect(mail.body.encoded).to match(platform_invitation.greeting.to_plain_text) + end + + it 'assigns @platform' do + expect(mail.body.encoded).to match(platform.name) + end + + it 'includes invitation URL' do + expect(mail.body.encoded).to match(/#{Regexp.escape(platform_invitation.url)}/) + end + + it 'includes greeting text' do + expect(mail.body.encoded).to match(/Welcome to our platform/) + end + end + + context 'with blank invitee_email' do + let(:platform_invitation) do + build(:platform_invitation, + invitable: platform, + invitee_email: '', + locale: 'en') + end + + it 'returns NullMail without sending' do + expect(mail.message).to be_a(ActionMailer::Base::NullMail) + end + end + + context 'with nil invitee_email' do + let(:platform_invitation) do + build(:platform_invitation, + invitable: platform, + invitee_email: nil, + locale: 'en') + end + + before do + # Skip validation to create record with nil email for testing + platform_invitation.save(validate: false) + end + + it 'returns nil without sending' do + mail = described_class.invite(platform_invitation) + expect(mail.to).to be_nil + end + end + + context 'with different locale' do + let(:platform_invitation) do + create(:platform_invitation, + invitable: platform, + invitee_email: 'invitee@example.com', + locale: 'es') + end + + around do |example| + I18n.with_locale(:es) do + example.run + end + end + + it 'uses the invitation locale for subject' do + expect(mail.subject).to be_present + end + + it 'sets the mailer locale' do + # The mailer should use the invitation's locale + expect(mail.body.encoded).to be_present + end + end + + context 'with different time zone' do + let(:platform) do + create(:platform, + name: 'Test Platform', + time_zone: 'Asia/Tokyo') + end + + it 'sends email with platform time zone awareness' do + expect(mail.to).to eq([platform_invitation.invitee_email]) + end + end + + context 'with valid_from and valid_until dates' do + let(:platform_invitation) do + create(:platform_invitation, + invitable: platform, + invitee_email: 'invitee@example.com', + valid_from: Date.parse('2025-01-01'), + valid_until: Date.parse('2025-12-31')) + end + + it 'includes validity period in email' do + # Email body should have access to @valid_from and @valid_until + expect(mail.body.encoded).to be_present + end + end + + context 'with HTML and text parts' do + it 'generates email with body' do + expect(mail.body.encoded).to be_present + end + + it 'includes HTML content' do + expect(mail.content_type).to match(/html/) + end + end + + context 'when platform has custom settings' do + let(:platform) do + create(:platform, + name: 'Custom Platform', + time_zone: 'Pacific/Auckland') + end + + it 'uses platform name in subject' do + expect(mail.subject).to include('Custom Platform') + end + end + + describe 'instance variable assignments' do + before { mail.deliver_now } + + it 'assigns @invitee_email' do + # Email appears as "invitee" in greeting, not full email address + expect(mail.body.encoded).to match('invitee') + end + + it 'assigns @greeting' do + expect(mail.body.encoded).to match(platform_invitation.greeting.to_plain_text) + end + + it 'assigns @valid_from and @valid_until' do + expect(mail.body.encoded).to be_present + end + + it 'assigns @invitation_url' do + expect(mail.body.encoded).to match(/invitation/) + end + end + end + end +end +# rubocop:enable Metrics/ModuleLength diff --git a/spec/models/better_together/address_spec.rb b/spec/models/better_together/address_spec.rb index d4344af0a..47457e175 100644 --- a/spec/models/better_together/address_spec.rb +++ b/spec/models/better_together/address_spec.rb @@ -2,10 +2,192 @@ require 'rails_helper' -module BetterTogether +module BetterTogether # rubocop:todo Metrics/ModuleLength RSpec.describe Address do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid address' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail) + expect(address).to be_valid + expect(address.label).to eq('work') + expect(address.physical).to be true + end + end + + describe 'associations' do + it { is_expected.to belong_to(:contact_detail).class_name('BetterTogether::ContactDetail').optional } + it { is_expected.to have_many(:buildings).class_name('BetterTogether::Infrastructure::Building') } + end + + describe 'validations' do + describe 'address type' do + it 'requires at least one address type (physical or postal)' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = build(:address, contact_detail: contact_detail, physical: false, postal: false) + expect(address).not_to be_valid + expect(address.errors[:base]).to be_present + end + + it 'accepts physical address' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail, physical: true, postal: false) + expect(address).to be_valid + end + + it 'accepts postal address' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail, physical: false, postal: true) + expect(address).to be_valid + end + + it 'accepts both physical and postal' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail, physical: true, postal: true) + expect(address).to be_valid + end + end + end + + describe 'PrimaryFlag concern' do + it 'includes PrimaryFlag behavior' do + expect(described_class.included_modules).to include(BetterTogether::PrimaryFlag) + end + + it 'allows setting primary_flag' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail, label: 'main', primary_flag: true) + expect(address.primary_flag).to be true + end + + it 'scopes primary flag by contact_detail_id' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + + address1 = create(:address, + contact_detail: contact_detail, + label: 'main', + line1: '123 Main St', + primary_flag: true) + + address2 = create(:address, + contact_detail: contact_detail, + label: 'work', + line1: '456 Work Ave', + primary_flag: false) + + expect(address1.primary_flag).to be true + expect(address2.primary_flag).to be false + end + end + + describe 'Privacy concern' do + it 'includes Privacy behavior' do + expect(described_class.included_modules).to include(BetterTogether::Privacy) + end + + it 'allows setting privacy level' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail, label: 'home', privacy: 'private') + expect(address.privacy).to eq('private') + end + end + + describe 'Labelable concern' do + it 'includes Labelable behavior' do + expect(described_class.included_modules).to include(BetterTogether::Labelable) + end + + it 'accepts valid labels' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + valid_labels = %w[main mailing physical home work billing shipping other] + + valid_labels.each do |label| + address = build(:address, contact_detail: contact_detail, label: label) + expect(address).to be_valid, "Expected #{label} to be valid" + end + end + + it 'defines expected label constants' do + expect(described_class::LABELS).to include(:main, :mailing, :physical, :home, :work, :billing, :shipping, :other) + end + end + + describe 'geolocation' do + it 'includes Geography::Geospatial::One behavior' do + expect(described_class.included_modules).to include(BetterTogether::Geography::Geospatial::One) + end + + it 'responds to geocoding_string method' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail) + expect(address).to respond_to(:geocoding_string) + end + + it 'builds geocoding string from address components' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail, + line1: '62 Broadway', + city_name: 'Corner Brook', + state_province_name: 'Newfoundland and Labrador', + postal_code: 'A2H 4C2', + country_name: 'Canada') + geocoding_string = address.geocoding_string + expect(geocoding_string).to include('62 Broadway') + expect(geocoding_string).to include('Corner Brook') + end + end + + describe 'string formatting' do + it 'responds to to_formatted_s' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail) + expect(address).to respond_to(:to_formatted_s) + end + + it 'formats address as string' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail, + line1: '62 Broadway', + city_name: 'Corner Brook', + state_province_name: 'NL', + postal_code: 'A2H 4C2') + formatted = address.to_s + expect(formatted).to include('62 Broadway') + expect(formatted).to include('Corner Brook') + end + + it 'supports short format' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + address = create(:address, contact_detail: contact_detail, + line1: '62 Broadway', + line2: 'Suite 100', + city_name: 'Corner Brook', + state_province_name: 'NL') + short = address.to_formatted_s(format: :short) + expect(short).to include('62 Broadway') + expect(short).not_to include('Suite 100') # line2 excluded in short format + end + end + + describe 'permitted_attributes' do + it 'includes address-specific attributes' do + attrs = described_class.permitted_attributes + expect(attrs).to include(:physical, :postal, :line1, :line2, :city_name, + :state_province_name, :postal_code, :country_name, :primary_flag) + end end end end diff --git a/spec/models/better_together/calendar_entry_spec.rb b/spec/models/better_together/calendar_entry_spec.rb index e3e6d9467..6279f4e7f 100644 --- a/spec/models/better_together/calendar_entry_spec.rb +++ b/spec/models/better_together/calendar_entry_spec.rb @@ -4,8 +4,92 @@ module BetterTogether RSpec.describe CalendarEntry do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid calendar entry' do + calendar_entry = create(:calendar_entry) + expect(calendar_entry).to be_valid + expect(calendar_entry.calendar).to be_present + expect(calendar_entry.event).to be_present + expect(calendar_entry.starts_at).to be_present + end + end + + describe 'associations' do + it { is_expected.to belong_to(:calendar).class_name('BetterTogether::Calendar') } + it { is_expected.to belong_to(:event).class_name('BetterTogether::Event') } + end + + describe 'validations' do + describe 'uniqueness' do + it 'validates event_id uniqueness scoped to calendar_id' do + calendar = create(:calendar) + event = create(:event) + + create(:calendar_entry, calendar: calendar, event: event) + duplicate = build(:calendar_entry, calendar: calendar, event: event) + + expect(duplicate).not_to be_valid + expect(duplicate.errors[:event_id]).to include('has already been taken') + end + + it 'allows same event in different calendars' do + event = create(:event) + calendar1 = create(:calendar) + calendar2 = create(:calendar) + + entry1 = create(:calendar_entry, calendar: calendar1, event: event) + entry2 = build(:calendar_entry, calendar: calendar2, event: event) + + expect(entry1).to be_valid + expect(entry2).to be_valid + end + + it 'allows different events in same calendar' do + calendar = create(:calendar) + event1 = create(:event) + event2 = create(:event) + + entry1 = create(:calendar_entry, calendar: calendar, event: event1) + entry2 = build(:calendar_entry, calendar: calendar, event: event2) + + expect(entry1).to be_valid + expect(entry2).to be_valid + end + end + end + + describe 'scheduling attributes' do + it 'tracks start and end times' do + starts = 1.week.from_now + ends = starts + 2.hours + + entry = create(:calendar_entry, starts_at: starts, ends_at: ends) + + expect(entry.starts_at).to be_within(1.second).of(starts) + expect(entry.ends_at).to be_within(1.second).of(ends) + end + + it 'tracks duration in minutes' do + entry = create(:calendar_entry, duration_minutes: 90) + expect(entry.duration_minutes).to eq(90) + end + + it 'allows nil ends_at' do + entry = create(:calendar_entry, ends_at: nil) + expect(entry.ends_at).to be_nil + expect(entry).to be_valid + end + end + + describe 'join model behavior' do + it 'links calendar and event' do + calendar = create(:calendar) + event = create(:event) + calendar_entry = create(:calendar_entry, calendar: calendar, event: event) + + expect(calendar_entry.calendar).to eq(calendar) + expect(calendar_entry.event).to eq(event) + end end end end diff --git a/spec/models/better_together/call_for_interest_spec.rb b/spec/models/better_together/call_for_interest_spec.rb index 3b3fe0e6f..5eb532490 100644 --- a/spec/models/better_together/call_for_interest_spec.rb +++ b/spec/models/better_together/call_for_interest_spec.rb @@ -2,10 +2,137 @@ require 'rails_helper' -module BetterTogether +module BetterTogether # rubocop:disable Metrics/ModuleLength RSpec.describe CallForInterest do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid call for interest' do + call = build(:call_for_interest) + expect(call).to be_valid + end + + it 'creates draft calls for interest' do + call = create(:call_for_interest, :draft) + expect(call.starts_at).to be_nil + expect(call.ends_at).to be_nil + end + + it 'creates calls with events' do + call = create(:call_for_interest, :with_event) + expect(call.interestable).to be_an(Event) + end + end + + describe 'associations' do + it { is_expected.to belong_to(:interestable).optional } + it { is_expected.to belong_to(:creator) } + end + + describe 'validations' do + it 'validates cover image content type' do + call = build(:call_for_interest) + expect(call).to be_valid + end + end + + describe 'translatable attributes' do + it 'has translatable name' do + call = create(:call_for_interest, name: 'Test Call') + expect(call.name).to eq('Test Call') + end + + it 'has translatable description' do + call = create(:call_for_interest, description: 'Test Description') + expect(call.description).to be_present + end + end + + describe 'scopes' do + let!(:draft_call) { create(:call_for_interest, :draft) } + let!(:upcoming_call) { create(:call_for_interest, :upcoming) } + let!(:past_call) { create(:call_for_interest, :past) } + + describe '.draft' do + it 'returns only draft calls' do + expect(described_class.draft).to include(draft_call) + expect(described_class.draft).not_to include(upcoming_call, past_call) + end + end + + describe '.upcoming' do + it 'returns only upcoming calls' do + expect(described_class.upcoming).to include(upcoming_call) + expect(described_class.upcoming).not_to include(past_call, draft_call) + end + end + + describe '.past' do + it 'returns only past calls' do + expect(described_class.past).to include(past_call) + expect(described_class.past).not_to include(upcoming_call, draft_call) + end + end + end + + describe 'privacy levels' do + it 'supports public privacy' do + call = create(:call_for_interest, privacy: 'public') + expect(call.privacy).to eq('public') + end + + it 'supports private privacy' do + call = create(:call_for_interest, :private) + expect(call.privacy).to eq('private') + end + end + + describe 'polymorphic interestable' do + it 'can be associated with an event' do + event = create(:event) + call = create(:call_for_interest, interestable: event) + + expect(call.interestable).to eq(event) + expect(call.interestable_type).to eq('BetterTogether::Event') + end + + it 'allows nil interestable' do + call = create(:call_for_interest, interestable: nil) + expect(call.interestable).to be_nil + end + end + + describe 'timing attributes' do + it 'tracks starts_at' do + time = 1.week.from_now + call = create(:call_for_interest, starts_at: time) + expect(call.starts_at).to be_within(1.second).of(time) + end + + it 'tracks ends_at' do + time = 2.weeks.from_now + call = create(:call_for_interest, ends_at: time) + expect(call.ends_at).to be_within(1.second).of(time) + end + + it 'allows nil starts_at for drafts' do + call = create(:call_for_interest, :draft) + expect(call.starts_at).to be_nil + end + + it 'allows nil ends_at' do + call = create(:call_for_interest, starts_at: 1.week.from_now, ends_at: nil) + expect(call.ends_at).to be_nil + end + end + + describe 'identifier behavior' do + it 'generates unique identifiers' do + call1 = create(:call_for_interest) + call2 = create(:call_for_interest) + + expect(call1.identifier).to be_present + expect(call2.identifier).to be_present + expect(call1.identifier).not_to eq(call2.identifier) + end end end end diff --git a/spec/models/better_together/categorization_spec.rb b/spec/models/better_together/categorization_spec.rb index 43504b79e..f4c18a19b 100644 --- a/spec/models/better_together/categorization_spec.rb +++ b/spec/models/better_together/categorization_spec.rb @@ -4,8 +4,117 @@ module BetterTogether RSpec.describe Categorization do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid categorization' do + categorization = build(:categorization) + expect(categorization).to be_valid + end + + it 'creates categorization with event and event_category' do + categorization = create(:categorization, + category: create(:event_category), + categorizable: create(:event)) + expect(categorization.category).to be_an(EventCategory) + expect(categorization.categorizable).to be_an(Event) + end + + it 'creates categorization with page and category' do + categorization = create(:categorization, + category: create(:category), + categorizable: create(:page)) + expect(categorization.category).to be_a(Category) + expect(categorization.categorizable).to be_a(Page) + end + end + + describe 'associations' do + it { is_expected.to belong_to(:category) } + it { is_expected.to belong_to(:categorizable) } + + it 'touches categorizable on save' do + categorization = create(:categorization) + categorizable = categorization.categorizable + + # The touch: true option means updating the categorization + # will update the categorizable's updated_at + expect { categorization.touch }.to(change { categorizable.reload.updated_at }) + end + end + + describe 'polymorphic category' do + it 'accepts Category as category' do + category = create(:category) + categorization = create(:categorization, category: category) + + expect(categorization.category).to eq(category) + expect(categorization.category_type).to eq('BetterTogether::Category') + end + + it 'accepts EventCategory as category' do + event_category = create(:event_category) + categorization = create(:categorization, category: event_category) + + expect(categorization.category).to be_a(EventCategory) + # STI stores base class type in polymorphic associations + expect(categorization.category_type).to eq('BetterTogether::Category') + end + end + + describe 'polymorphic categorizable' do + it 'accepts Event as categorizable' do + event = create(:event) + categorization = create(:categorization, categorizable: event) + + expect(categorization.categorizable).to eq(event) + expect(categorization.categorizable_type).to eq('BetterTogether::Event') + end + + it 'accepts Page as categorizable' do + page = create(:page) + categorization = create(:categorization, categorizable: page) + + expect(categorization.categorizable).to eq(page) + expect(categorization.categorizable_type).to eq('BetterTogether::Page') + end + end + + describe 'join table behavior' do + it 'links category and categorizable' do + category = create(:category) + page = create(:page) + categorization = create(:categorization, + category: category, + categorizable: page) + + expect(categorization.category).to eq(category) + expect(categorization.categorizable).to eq(page) + end + + it 'allows same categorizable in different categories' do + page = create(:page) + category1 = create(:category) + category2 = create(:category) + + cat1 = create(:categorization, category: category1, categorizable: page) + cat2 = create(:categorization, category: category2, categorizable: page) + + expect(cat1.categorizable).to eq(page) + expect(cat2.categorizable).to eq(page) + expect(cat1.category).not_to eq(cat2.category) + end + + it 'allows same category for different categorizables' do + category = create(:category) + page1 = create(:page) + page2 = create(:page) + + cat1 = create(:categorization, category: category, categorizable: page1) + cat2 = create(:categorization, category: category, categorizable: page2) + + expect(cat1.category).to eq(category) + expect(cat2.category).to eq(category) + expect(cat1.categorizable).not_to eq(cat2.categorizable) + end end end end diff --git a/spec/models/better_together/category_spec.rb b/spec/models/better_together/category_spec.rb index 945ef834b..ce079dec8 100644 --- a/spec/models/better_together/category_spec.rb +++ b/spec/models/better_together/category_spec.rb @@ -4,8 +4,110 @@ module BetterTogether RSpec.describe Category do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid category' do + category = build(:category) + expect(category).to be_valid + end + + it 'creates categories with custom icons' do + category = create(:category, :with_custom_icon) + expect(category.icon).to eq('fas fa-star') + end + end + + describe 'associations' do + it { is_expected.to have_many(:categorizations).dependent(:destroy) } + it { is_expected.to have_many(:pages).through(:categorizations) } + end + + describe 'validations' do + it { is_expected.to validate_presence_of(:name) } + it { is_expected.to validate_presence_of(:type) } + end + + describe 'translatable attributes' do + it 'has translatable name' do + category = create(:category, name: 'Test Category') + expect(category.name).to eq('Test Category') + end + + it 'has translatable description' do + category = create(:category, description: 'Test Description') + expect(category.description).to be_present + end + end + + describe '#as_category' do + it 'returns self when already base class' do + category = create(:category) + expect(category.as_category).to eq(category) + end + + it 'converts subclass to base Category' do + event_category = create(:event_category) + as_category = event_category.as_category + + expect(as_category).to be_a(described_class) + expect(as_category.id).to eq(event_category.id) + end + end + + describe 'STI behavior' do + it 'uses type column for STI' do + category = create(:category) + expect(category.type).to eq('BetterTogether::Category') + end + + it 'supports subclasses like EventCategory' do + event_category = create(:event_category) + expect(event_category).to be_a(described_class) + expect(event_category.type).to eq('BetterTogether::EventCategory') + end + end + + describe 'categorization' do + it 'can categorize pages' do + category = create(:category) + page = create(:page) + categorization = create(:categorization, + category: category, + categorizable: page) + + expect(category.pages).to include(page) + expect(category.categorizations).to include(categorization) + end + + it 'removes categorizations when destroyed' do + category = create(:category) + page = create(:page) + create(:categorization, category: category, categorizable: page) + + expect { category.destroy }.to change(Categorization, :count).by(-1) + end + end + + describe 'identifier behavior' do + it 'generates unique identifiers' do + cat1 = create(:category) + cat2 = create(:category) + + expect(cat1.identifier).to be_present + expect(cat2.identifier).to be_present + expect(cat1.identifier).not_to eq(cat2.identifier) + end + end + + describe 'icon attribute' do + it 'has default icon value' do + category = create(:category) + expect(category.icon).to be_present + end + + it 'stores custom icon value when provided' do + category = create(:category, icon: 'fas fa-star') + expect(category.icon).to eq('fas fa-star') + end end end end diff --git a/spec/models/better_together/comment_spec.rb b/spec/models/better_together/comment_spec.rb index 143ca9f43..b21d75bce 100644 --- a/spec/models/better_together/comment_spec.rb +++ b/spec/models/better_together/comment_spec.rb @@ -2,10 +2,141 @@ require 'rails_helper' -module BetterTogether - RSpec.describe Comment do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be +RSpec.describe BetterTogether::Comment do + describe 'database schema' do + let(:post) { create(:post) } + + it 'has the expected columns' do + expect(described_class.column_names).to include( + 'id', + 'commentable_type', + 'commentable_id', + 'creator_id', + 'content', + 'created_at', + 'updated_at', + 'lock_version' + ) + end + + it 'has a UUID primary key' do + comment = described_class.create!( + content: 'Test', + commentable_type: 'BetterTogether::Post', + commentable_id: post.id + ) + expect(comment.id).to be_present + expect(comment.id).to be_a(String) + end + + it 'has lock_version for optimistic locking' do + comment = described_class.create!( + content: 'Test', + commentable_type: 'BetterTogether::Post', + commentable_id: post.id + ) + expect(comment.lock_version).to eq(0) + end + end + + describe 'content field' do + let(:post) { create(:post) } + + it 'has a default empty string for content' do + comment = described_class.new + expect(comment.content).to eq('') + end + + it 'stores text content' do + comment = described_class.create!( + content: 'This is my comment', + commentable_type: 'BetterTogether::Post', + commentable_id: post.id + ) + expect(comment.reload.content).to eq('This is my comment') + end + + it 'allows content to be updated' do + comment = described_class.create!( + content: 'Original', + commentable_type: 'BetterTogether::Post', + commentable_id: post.id + ) + comment.update!(content: 'Updated') + expect(comment.reload.content).to eq('Updated') + end + end + + describe 'polymorphic fields' do + it 'has commentable_type and commentable_id fields' do + comment = described_class.new + expect(comment).to respond_to(:commentable_type) + expect(comment).to respond_to(:commentable_id) + end + + it 'can store different commentable types' do + post = create(:post) + page = create(:page) + + comment1 = described_class.create!( + commentable_type: 'BetterTogether::Post', + commentable_id: post.id, + content: 'Comment on post' + ) + comment2 = described_class.create!( + commentable_type: 'BetterTogether::Page', + commentable_id: page.id, + content: 'Comment on page' + ) + + expect(comment1.commentable_type).to eq('BetterTogether::Post') + expect(comment2.commentable_type).to eq('BetterTogether::Page') + end + end + + describe 'creator field' do + let(:post) { create(:post) } + + it 'has a creator_id field' do + comment = described_class.new + expect(comment).to respond_to(:creator_id) + end + + it 'can store creator_id' do + person = create(:person) + comment = described_class.create!( + creator_id: person.id, + content: 'Test comment', + commentable_type: 'BetterTogether::Post', + commentable_id: post.id + ) + expect(comment.reload.creator_id).to eq(person.id) + end + end + + describe 'timestamps' do + let(:post) { create(:post) } + + it 'sets created_at on creation' do + comment = described_class.create!( + content: 'Test', + commentable_type: 'BetterTogether::Post', + commentable_id: post.id + ) + expect(comment.created_at).to be_present + expect(comment.created_at).to be_within(1.second).of(Time.current) + end + + it 'updates updated_at on save' do + comment = described_class.create!( + content: 'Test', + commentable_type: 'BetterTogether::Post', + commentable_id: post.id + ) + original_updated_at = comment.updated_at + sleep 0.01 + comment.update!(content: 'Updated') + expect(comment.updated_at).to be > original_updated_at end end end diff --git a/spec/models/better_together/contact_detail_spec.rb b/spec/models/better_together/contact_detail_spec.rb index 6cde97fce..0c88e5d2e 100644 --- a/spec/models/better_together/contact_detail_spec.rb +++ b/spec/models/better_together/contact_detail_spec.rb @@ -4,8 +4,89 @@ module BetterTogether RSpec.describe ContactDetail do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid contact detail' do + contact_detail = build(:contact_detail) + expect(contact_detail).to be_valid + end + end + + describe 'associations' do + it { is_expected.to belong_to(:contactable) } + it { is_expected.to have_many(:phone_numbers).dependent(:destroy) } + it { is_expected.to have_many(:email_addresses).dependent(:destroy) } + it { is_expected.to have_many(:addresses).dependent(:destroy) } + it { is_expected.to have_many(:social_media_accounts).dependent(:destroy) } + it { is_expected.to have_many(:website_links).dependent(:destroy) } + end + + describe 'polymorphic contactable' do + it 'can belong to a person' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + + expect(contact_detail.contactable).to eq(person) + expect(contact_detail.contactable_type).to eq('BetterTogether::Person') + end + + it 'can belong to a community' do + community = create(:community) + contact_detail = create(:contact_detail, contactable: community) + + expect(contact_detail.contactable).to eq(community) + expect(contact_detail.contactable_type).to eq('BetterTogether::Community') + end + end + + describe '#has_contact_details?' do + it 'returns false when no details present' do + contact_detail = create(:contact_detail) + expect(contact_detail.has_contact_details?).to be false + end + + it 'checks for presence of any contact detail type' do + contact_detail = create(:contact_detail) + expect(contact_detail).to respond_to(:has_contact_details?) + end + end + + describe 'nested attributes support' do + it 'accepts nested attributes for phone numbers' do + contact_detail = create(:contact_detail) + expect(contact_detail).to accept_nested_attributes_for(:phone_numbers).allow_destroy(true) + end + + it 'accepts nested attributes for email addresses' do + contact_detail = create(:contact_detail) + expect(contact_detail).to accept_nested_attributes_for(:email_addresses).allow_destroy(true) + end + + it 'accepts nested attributes for addresses' do + contact_detail = create(:contact_detail) + expect(contact_detail).to accept_nested_attributes_for(:addresses).allow_destroy(true) + end + + it 'accepts nested attributes for social media accounts' do + contact_detail = create(:contact_detail) + expect(contact_detail).to accept_nested_attributes_for(:social_media_accounts).allow_destroy(true) + end + + it 'accepts nested attributes for website links' do + contact_detail = create(:contact_detail) + expect(contact_detail).to accept_nested_attributes_for(:website_links).allow_destroy(true) + end + end + + describe 'safe touch behavior' do + it 'touches contactable after create' do + person = create(:person) + original_time = person.updated_at + + sleep 0.01 # Small delay to ensure time difference + create(:contact_detail, contactable: person) + + expect(person.reload.updated_at).to be > original_time + end end end end diff --git a/spec/models/better_together/content/block_spec.rb b/spec/models/better_together/content/block_spec.rb new file mode 100644 index 000000000..50d85e9d4 --- /dev/null +++ b/spec/models/better_together/content/block_spec.rb @@ -0,0 +1,243 @@ +# frozen_string_literal: true + +require 'rails_helper' + +module BetterTogether + module Content # rubocop:todo Metrics/ModuleLength + RSpec.describe Block do + # Block is an abstract base class - test through concrete subclasses + # We use Html as the default concrete implementation for most tests + + describe 'Associations' do + subject { build(:better_together_content_html) } + + it { is_expected.to have_many(:page_blocks).dependent(:destroy) } + it { is_expected.to have_many(:pages).through(:page_blocks) } + end + + describe 'Validations' do + # Test through concrete subclass since Block is abstract + subject { build(:better_together_content_html) } + + describe 'identifier' do + it { is_expected.to validate_length_of(:identifier).is_at_most(100) } + + it 'validates uniqueness across all block types' do + create(:better_together_content_html, identifier: 'unique-block') + duplicate = build(:better_together_content_html, identifier: 'unique-block') + expect(duplicate).not_to be_valid + expect(duplicate.errors[:identifier]).to be_present + end + + it 'allows blank identifier' do + block = build(:better_together_content_html, identifier: '') + expect(block).to be_valid + end + end + end + + describe 'Instance Methods' do + # All instance method tests use concrete Html subclass + describe '#identifier=' do + it 'parameterizes the identifier' do + block = build(:better_together_content_html) + block.identifier = 'My Test Block' + expect(block.identifier).to eq('my-test-block') + end + + it 'handles special characters' do + block = build(:better_together_content_html) + block.identifier = 'Test & Special! Characters?' + expect(block.identifier).to eq('test-special-characters') + end + + it 'handles spaces and hyphens' do + block = build(:better_together_content_html) + block.identifier = 'test-block with spaces' + expect(block.identifier).to eq('test-block-with-spaces') + end + end + + describe '#to_partial_path' do + it 'returns the partial path for a block' do + block = create(:better_together_content_html) + expect(block.to_partial_path).to eq('better_together/content/blocks/html') + end + + it 'uses block_name in partial path' do + hero = create(:better_together_content_hero) + expect(hero.to_partial_path).to eq('better_together/content/blocks/hero') + end + end + + describe '#block_name' do + it 'returns the underscored class name without module' do + block = create(:better_together_content_html) + expect(block.block_name).to eq('html') + end + + it 'works for different block types' do + hero = create(:better_together_content_hero) + css = create(:better_together_content_css) + + expect(hero.block_name).to eq('hero') + expect(css.block_name).to eq('css') + end + end + + describe '#to_s' do + it 'returns block_name with identifier for persisted block' do + block = create(:better_together_content_html, identifier: 'test-block') + expect(block.to_s).to eq('html - test-block') + end + + it 'returns "new" for unpersisted blocks' do + block = build(:better_together_content_html) + expect(block.to_s).to eq('html - new') + end + end + + describe '#cached_content' do + it 'returns a hash with id, type, content, and translations' do + block = create(:better_together_content_html, content: '
- ')
+ expect(html).to include('
strikethrough') + end + end + end + + describe '#rendered_plain_text' do + let(:markdown) { described_class.new(markdown_source: markdown_source) } + + context 'with basic markdown' do + let(:markdown_source) { '# Hello **World**' } + + it 'returns plain text without HTML tags' do + plain = markdown.rendered_plain_text + expect(plain).not_to match(/<[^>]+>/) + expect(plain).to include('Hello') + expect(plain).to include('World') + end + end + + context 'with complex markdown' do + let(:markdown_source) do + <<~MD + # Title + + This is **bold** and *italic*. + + - Item 1 + - Item 2 + MD + end + + it 'extracts all text content' do + plain = markdown.rendered_plain_text + expect(plain).to include('Title') + expect(plain).to include('bold') + expect(plain).to include('italic') + expect(plain).to include('Item 1') + expect(plain).to include('Item 2') + end + end + end + + describe '#as_indexed_json' do + let(:markdown_source) { '# Searchable Content' } + let(:markdown) { described_class.create!(markdown_source: markdown_source) } + + it 'returns a hash with id and localized_content' do + result = markdown.as_indexed_json + + expect(result).to be_a(Hash) + expect(result.keys).to contain_exactly(:id, :localized_content) + end + + it 'includes the markdown id' do + result = markdown.as_indexed_json + expect(result[:id]).to eq(markdown.id) + end + + it 'includes localized content' do + result = markdown.as_indexed_json + + expect(result[:localized_content]).to be_a(Hash) + expect(result[:localized_content].keys).to match_array(I18n.available_locales) + end + + it 'includes plain text content for each locale' do + result = markdown.as_indexed_json + + I18n.available_locales.each do |locale| + expect(result[:localized_content][locale]).to be_a(String) + expect(result[:localized_content][locale]).to include('Searchable Content') + end + end + end + + describe 'integration with Page model' do + let(:page) do + BetterTogether::Page.create!( + title: 'Markdown Test Page', + slug: 'markdown-test', + privacy: 'public', + page_blocks_attributes: [ + { + block_attributes: { + type: 'BetterTogether::Content::Markdown', + markdown_source: '# Test Markdown Content' + } + } + ] + ) + end + + it 'can be associated with pages through page_blocks' do + expect(page.content_blocks.count).to eq(1) + expect(page.content_blocks.first).to be_a(described_class) + end + + it 'is included in page indexed data' do + indexed_data = page.as_indexed_json + expect(indexed_data).to be_present + end + end + + describe 'store_attributes' do + it 'stores markdown_source via Mobility (not in content_data)' do + markdown = described_class.new(markdown_source: '# Test') + # markdown_source is now stored via Mobility translations, not storext + expect(markdown.markdown_source).to eq('# Test') + expect(markdown.content_data).not_to include('markdown_source') + end + + it 'stores markdown_file_path in content_data' do + markdown = described_class.new(markdown_file_path: '/path/to/file.md') + expect(markdown.content_data).to include('markdown_file_path') + end + + it 'stores auto_sync_from_file in content_data' do + markdown = described_class.new(auto_sync_from_file: true) + expect(markdown.content_data).to include('auto_sync_from_file') + expect(markdown.auto_sync_from_file).to be true + end + end + + describe 'caching' do + let(:markdown) { described_class.create!(markdown_source: '# Cached Content') } + + it 'has a cache_key_with_version' do + expect(markdown.cache_key_with_version).to be_present + end + + it 'cache key changes when content updates' do + original_key = markdown.cache_key_with_version + markdown.update!(markdown_source: '# Updated Content') + expect(markdown.cache_key_with_version).not_to eq(original_key) + end + end +end diff --git a/spec/models/better_together/content/platform_block_spec.rb b/spec/models/better_together/content/platform_block_spec.rb new file mode 100644 index 000000000..85c473406 --- /dev/null +++ b/spec/models/better_together/content/platform_block_spec.rb @@ -0,0 +1,57 @@ +# frozen_string_literal: true + +require 'rails_helper' + +module BetterTogether + module Content + RSpec.describe PlatformBlock do + describe 'Associations' do + it { is_expected.to belong_to(:platform).class_name('BetterTogether::Platform').touch(true) } + it { is_expected.to belong_to(:block).class_name('BetterTogether::Content::Block').autosave(true) } + end + + describe 'Nested Attributes' do + it 'accepts nested attributes for block' do + platform = create(:better_together_platform) + + platform_block = described_class.new( + platform: platform, + block_attributes: { + type: 'BetterTogether::Content::Html', + identifier: 'test-block', + privacy: 'public' + } + ) + + # Should accept the nested attributes without error + expect { platform_block.save }.not_to raise_error + end + end + + describe 'Integration' do + it 'creates with platform and block' do + platform = create(:better_together_platform) + block = create(:better_together_content_html, content: 'Test content
') + + platform_block = described_class.create!(platform: platform, block: block) + + expect(platform_block).to be_persisted + expect(platform_block.platform).to eq(platform) + expect(platform_block.block).to eq(block) + end + + it 'touches platform when updated' do + platform = create(:better_together_platform) + block = create(:better_together_content_html) + platform_block = described_class.create!(platform: platform, block: block) + + original_updated_at = platform.reload.updated_at + sleep 0.01 # Ensure time difference + platform_block.touch + + expect(platform.reload.updated_at).to be > original_updated_at + end + end + end + end +end diff --git a/spec/models/better_together/content/rich_text_spec.rb b/spec/models/better_together/content/rich_text_spec.rb new file mode 100644 index 000000000..65d3e1ae0 --- /dev/null +++ b/spec/models/better_together/content/rich_text_spec.rb @@ -0,0 +1,132 @@ +# frozen_string_literal: true + +require 'rails_helper' + +module BetterTogether + module Content # rubocop:todo Metrics/ModuleLength + RSpec.describe RichText do + describe 'Factory' do + it 'has a valid factory' do + rich_text_block = build(:better_together_content_rich_text) + expect(rich_text_block).to be_valid + end + + it 'creates with custom content' do + rich_text_block = create(:better_together_content_rich_text, content_html: 'Custom Heading
') + expect(rich_text_block.content.to_s).to include('Custom Heading') + end + end + + describe 'Associations' do + it { is_expected.to have_many(:page_blocks).dependent(:destroy) } + it { is_expected.to have_many(:pages).through(:page_blocks) } + end + + describe 'Inheritance' do + it 'inherits from Block' do + expect(described_class.superclass).to eq(Block) + end + end + + describe 'Translatable Attributes' do + it { is_expected.to respond_to(:content) } + + it 'supports translations for content via Action Text' do + rich_text_block = create(:better_together_content_rich_text) + + I18n.with_locale(:en) do + rich_text_block.content = 'English content
' + rich_text_block.save! + end + + I18n.with_locale(:fr) do + rich_text_block.content = 'Contenu français
' + rich_text_block.save! + end + + I18n.with_locale(:en) do + expect(rich_text_block.content.to_s).to include('English content') + end + + I18n.with_locale(:fr) do + expect(rich_text_block.content.to_s).to include('Contenu français') + end + end + end + + describe 'Action Text Integration' do + it 'uses Action Text backend for content translation' do + rich_text_block = create(:better_together_content_rich_text) + expect(rich_text_block.content).to be_a(ActionText::RichText) + end + + it 'preserves HTML formatting' do + rich_text_block = create(:better_together_content_rich_text, + content_html: 'Heading
Paragraph
') + content_string = rich_text_block.content.to_s + expect(content_string).to include('Heading
') + expect(content_string).to include('Paragraph
') + end + end + + describe 'Store Attributes' do + describe 'custom_css' do + it { is_expected.to respond_to(:css_classes) } + + it 'can store custom CSS classes' do + rich_text_block = create(:better_together_content_rich_text) + rich_text_block.update(css_classes: 'container mt-4') + expect(rich_text_block.css_classes).to eq('container mt-4') + end + + it 'has default my-5 CSS classes' do + rich_text_block = create(:better_together_content_rich_text) + expect(rich_text_block.css_classes).to eq('my-5') + end + end + end + + describe 'Instance Methods' do + describe '#indexed_localized_content' do + it 'returns hash with localized plain text content' do + rich_text_block = create(:better_together_content_rich_text, + content_html: 'Searchable content
') + + localized_content = rich_text_block.indexed_localized_content + expect(localized_content).to be_an(Array) + expect(localized_content.first).to include('Searchable content') + end + + it 'strips HTML tags for indexing' do + rich_text_block = create(:better_together_content_rich_text, + content_html: 'Bold text') + + localized_content = rich_text_block.indexed_localized_content + expect(localized_content.first).not_to include('') + expect(localized_content.first).to include('Bold') + end + end + + describe '#as_indexed_json' do + it 'includes basic attributes for Elasticsearch indexing' do + rich_text_block = create(:better_together_content_rich_text) + json = rich_text_block.as_indexed_json + + expect(json).to have_key(:id) + expect(json).to have_key(:identifier) + expect(json).to have_key(:localized_content) + end + + it 'includes indexed_localized_content' do + rich_text_block = create(:better_together_content_rich_text, + content_html: 'Test content
') + + json = rich_text_block.as_indexed_json + expect(json[:localized_content]).to be_an(Array) + expect(json[:localized_content].first).to include('Test content') + end + end + end + end + end +end diff --git a/spec/models/better_together/content/template_spec.rb b/spec/models/better_together/content/template_spec.rb new file mode 100644 index 000000000..854648034 --- /dev/null +++ b/spec/models/better_together/content/template_spec.rb @@ -0,0 +1,199 @@ +# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe BetterTogether::Content::Template do + describe 'associations' do + it { is_expected.to have_many(:page_blocks).dependent(:destroy) } + it { is_expected.to have_many(:pages).through(:page_blocks) } + end + + describe 'validations' do + it { is_expected.to validate_presence_of(:template_path) } + + it 'validates template_path is in available_templates list' do + template = described_class.new(template_path: 'invalid/path') + expect(template).not_to be_valid + expect(template.errors[:template_path]).to include('is not included in the list') + end + + it 'accepts valid template paths' do + described_class.available_templates.each do |valid_path| + template = described_class.new(template_path: valid_path) + template.valid? + expect(template.errors[:template_path]).to be_empty + end + end + end + + describe 'available_templates' do + it 'includes static page templates' do + expect(described_class.available_templates).to include( + 'better_together/static_pages/privacy', + 'better_together/static_pages/terms_of_service', + 'better_together/static_pages/code_of_conduct', + 'better_together/static_pages/accessibility', + 'better_together/static_pages/cookie_consent' + ) + end + + it 'includes contributor agreement templates' do + expect(described_class.available_templates).to include( + 'better_together/static_pages/code_contributor_agreement', + 'better_together/static_pages/content_contributor_agreement' + ) + end + + it 'includes other static pages' do + expect(described_class.available_templates).to include( + 'better_together/static_pages/faq', + 'better_together/static_pages/better_together', + 'better_together/static_pages/community_engine', + 'better_together/static_pages/subprocessors' + ) + end + + it 'includes content block templates' do + expect(described_class.available_templates).to include( + 'better_together/content/blocks/template/default', + 'better_together/content/blocks/template/host_community_contact_details' + ) + end + end + + describe '#as_indexed_json' do + let(:template) do + described_class.create!( + template_path: 'better_together/static_pages/privacy' + ) + end + + it 'returns a hash with id and localized_content' do + result = template.as_indexed_json + + expect(result).to be_a(Hash) + expect(result.keys).to contain_exactly(:id, :localized_content) + end + + it 'includes the template id' do + result = template.as_indexed_json + + expect(result[:id]).to eq(template.id) + end + + it 'includes localized content' do + result = template.as_indexed_json + + expect(result[:localized_content]).to be_a(Hash) + expect(result[:localized_content].keys).to match_array(I18n.available_locales) + end + end + + describe '#indexed_localized_content' do + let(:template) do + described_class.create!( + template_path: 'better_together/static_pages/privacy' + ) + end + + it 'returns a hash of locale to rendered content' do + result = template.indexed_localized_content + + expect(result).to be_a(Hash) + expect(result.keys).to match_array(I18n.available_locales) + end + + it 'renders content for each locale' do + result = template.indexed_localized_content + + I18n.available_locales.each do |locale| + expect(result[locale]).to be_a(String) + expect(result[locale]).not_to be_empty + end + end + + it 'returns plain text without HTML tags' do + result = template.indexed_localized_content + + result.each_value do |content| + expect(content).not_to match(/<[^>]+>/) + end + end + + it 'extracts meaningful text from templates' do + result = template.indexed_localized_content + + expect(result[:en]).to include('Better Together') + expect(result[:en]).to include('privacy') + end + + it 'uses TemplateRendererService' do + expect(BetterTogether::TemplateRendererService).to receive(:new) + .with(template.template_path) + .and_call_original + + template.indexed_localized_content + end + + context 'with different template paths' do + it 'renders privacy policy content' do + template.update!(template_path: 'better_together/static_pages/privacy') + result = template.indexed_localized_content + + expect(result[:en]).to include('privacy') + end + + it 'renders terms of service content' do + template.update!(template_path: 'better_together/static_pages/terms_of_service') + result = template.indexed_localized_content + + expect(result[:en]).not_to be_empty + end + + it 'renders content block templates' do + template.update!(template_path: 'better_together/content/blocks/template/default') + result = template.indexed_localized_content + + expect(result[:en]).to be_a(String) + end + end + end + + describe 'integration with Page model' do + let(:page) do + BetterTogether::Page.create!( + title: 'Test Page', + slug: 'test-page', + privacy: 'public', + page_blocks_attributes: [ + { + block_attributes: { + type: 'BetterTogether::Content::Template', + template_path: 'better_together/static_pages/privacy' + } + } + ] + ) + end + + it 'can be associated with pages through page_blocks' do + expect(page.template_blocks.count).to eq(1) + expect(page.template_blocks.first).to be_a(described_class) + end + + it 'is indexed when page is indexed' do + indexed_data = page.as_indexed_json + + expect(indexed_data['template_blocks']).to be_present + expect(indexed_data['template_blocks'].first['indexed_localized_content']).to be_present + end + end + + describe 'store_attributes' do + it 'stores template_path in content_data' do + template = described_class.new(template_path: 'better_together/static_pages/privacy') + + expect(template.content_data).to include('template_path') + end + end +end diff --git a/spec/models/better_together/conversation_participant_spec.rb b/spec/models/better_together/conversation_participant_spec.rb index fed0f3873..67fb4875f 100644 --- a/spec/models/better_together/conversation_participant_spec.rb +++ b/spec/models/better_together/conversation_participant_spec.rb @@ -2,10 +2,66 @@ require 'rails_helper' -module BetterTogether - RSpec.describe ConversationParticipant do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be +RSpec.describe BetterTogether::ConversationParticipant do + describe 'factory' do + it 'creates a valid conversation participant' do + participant = build(:conversation_participant) + expect(participant).to be_valid + end + + it 'creates with custom conversation' do + conversation = create(:conversation) + participant = create(:conversation_participant, conversation: conversation) + expect(participant.conversation).to eq(conversation) + end + + it 'creates with custom person' do + person = create(:person) + participant = create(:conversation_participant, person: person) + expect(participant.person).to eq(person) + end + end + + describe 'associations' do + it { is_expected.to belong_to(:conversation) } + it { is_expected.to belong_to(:person) } + end + + describe 'database constraints' do + it 'ensures conversation cannot be null' do + participant = build(:conversation_participant, conversation: nil) + expect { participant.save!(validate: false) }.to raise_error(ActiveRecord::NotNullViolation) + end + + it 'ensures person cannot be null' do + participant = build(:conversation_participant, person: nil) + expect { participant.save!(validate: false) }.to raise_error(ActiveRecord::NotNullViolation) + end + end + + describe 'uniqueness' do + it 'allows same person in different conversations' do + person = create(:person) + conversation1 = create(:conversation) + conversation2 = create(:conversation) + + participant1 = create(:conversation_participant, person: person, conversation: conversation1) + participant2 = build(:conversation_participant, person: person, conversation: conversation2) + + expect(participant1).to be_persisted + expect(participant2).to be_valid + end + + it 'allows different people in same conversation' do + conversation = create(:conversation) + person1 = create(:person) + person2 = create(:person) + + participant1 = create(:conversation_participant, person: person1, conversation: conversation) + participant2 = build(:conversation_participant, person: person2, conversation: conversation) + + expect(participant1).to be_persisted + expect(participant2).to be_valid end end end diff --git a/spec/models/better_together/conversation_spec.rb b/spec/models/better_together/conversation_spec.rb index c93f88bc9..f228944a1 100644 --- a/spec/models/better_together/conversation_spec.rb +++ b/spec/models/better_together/conversation_spec.rb @@ -3,6 +3,165 @@ require 'rails_helper' RSpec.describe BetterTogether::Conversation do + describe 'factory' do + it 'creates a valid conversation' do + conversation = build(:conversation) + expect(conversation).to be_valid + end + + it 'includes creator as participant by default' do + conversation = create(:conversation) + expect(conversation.participants).to include(conversation.creator) + end + + it 'includes an initial message by default' do + conversation = create(:conversation) + expect(conversation.messages.count).to eq(1) + end + end + + describe 'associations' do + it { is_expected.to belong_to(:creator).class_name('BetterTogether::Person') } + it { is_expected.to have_many(:messages).dependent(:destroy) } + it { is_expected.to have_many(:conversation_participants).dependent(:destroy) } + it { is_expected.to have_many(:participants).through(:conversation_participants).source(:person) } + end + + describe 'validations' do + describe 'participant_ids presence on create' do + it 'validates participant_ids presence on create' do + creator = create(:person) + conversation = described_class.new( + title: 'Test', + creator: creator, + participant_ids: [] + ) + expect(conversation).not_to be_valid + expect(conversation.errors[:participant_ids]).to include("can't be blank") + end + + it 'allows update without participant_ids' do + conversation = create(:conversation) + conversation.title = 'Updated Title' + expect(conversation).to be_valid + end + end + + describe 'at_least_one_participant custom validation' do + it 'is invalid when all participants are removed' do + conversation = create(:conversation) + conversation.participants.clear + expect(conversation).not_to be_valid + expect(conversation.errors[:conversation_participants]).to be_present + end + + it 'is valid with at least one participant' do + conversation = create(:conversation) + expect(conversation.participants.count).to be >= 1 + expect(conversation).to be_valid + end + end + + describe 'first_message_content_present on create' do + it 'is invalid when message content is blank on create' do + creator = create(:person) + conversation = described_class.new( + title: 'Test', + creator: creator, + participant_ids: [creator.id], + messages_attributes: [{ sender: creator, content: '' }] + ) + expect(conversation).not_to be_valid + expect(conversation.errors[:messages]).to include("can't be blank") + end + + it 'is valid when message content is present on create' do + creator = create(:person) + conversation = described_class.new( + title: 'Test', + creator: creator, + participant_ids: [creator.id], + messages_attributes: [{ sender: creator, content: 'Hello!' }] + ) + expect(conversation).to be_valid + end + + it 'is valid when no messages are provided on create' do + creator = create(:person) + conversation = described_class.new( + title: 'Test', + creator: creator, + participant_ids: [creator.id] + ) + # NOTE: This will be invalid in practice due to factory defaults, + # but testing the validation logic in isolation + conversation.messages.clear + expect(conversation.errors[:messages]).to be_empty + end + end + end + + describe 'encryption' do + it 'encrypts the title deterministically' do + conversation1 = create(:conversation, title: 'Secret Title') + conversation2 = create(:conversation, title: 'Secret Title') + + # Deterministic encryption means same plaintext = same ciphertext + # But we can't directly access the encrypted value in the same way + # Instead, verify both decrypt to the same value + expect(conversation1.title).to eq('Secret Title') + expect(conversation2.title).to eq('Secret Title') + end + end + + describe 'nested attributes' do + it 'accepts nested attributes for messages' do + creator = create(:person) + conversation = described_class.create( + title: 'Test', + creator: creator, + participant_ids: [creator.id], + messages_attributes: [ + { sender: creator, content: 'First message' }, + { sender: creator, content: 'Second message' } + ] + ) + expect(conversation.messages.count).to eq(2) + expect(conversation.messages.first.content.to_plain_text).to eq('First message') + expect(conversation.messages.second.content.to_plain_text).to eq('Second message') + end + end + + describe '#first_message_content' do + it 'returns the plain text content of the first message' do + conversation = create(:conversation) + first_message = conversation.messages.first + expect(conversation.first_message_content).to eq(first_message.content.to_plain_text) + end + + it 'returns nil when there are no messages' do + conversation = build(:conversation) + conversation.messages.clear + expect(conversation.first_message_content).to be_nil + end + end + + describe '#to_s' do + it 'returns the title' do + conversation = build(:conversation, title: 'Test Conversation') + expect(conversation.to_s).to eq('Test Conversation') + end + end + + describe '.permitted_attributes' do + it 'returns the permitted attributes array' do + permitted = described_class.permitted_attributes + expect(permitted).to include(:title) + expect(permitted).to include({ participant_ids: [] }) + expect(permitted).to include({ messages_attributes: BetterTogether::Message.permitted_attributes }) + end + end + describe '#add_participant_safe' do let(:conversation) { create(:better_together_conversation) } let(:person) { create(:better_together_person) } @@ -14,6 +173,19 @@ expect(conversation.participants).to include(person) end + it 'does not add duplicate participants' do + conversation.add_participant_safe(person) + expect do + conversation.add_participant_safe(person) + end.not_to(change { conversation.participants.count }) + end + + it 'handles nil person gracefully' do + expect do + conversation.add_participant_safe(nil) + end.not_to(change { conversation.participants.count }) + end + # rubocop:todo RSpec/MultipleExpectations it 'retries once on ActiveRecord::StaleObjectError and succeeds' do # rubocop:todo RSpec/MultipleExpectations # rubocop:enable RSpec/MultipleExpectations diff --git a/spec/models/better_together/email_address_spec.rb b/spec/models/better_together/email_address_spec.rb index 5b43ef6d8..45eef012f 100644 --- a/spec/models/better_together/email_address_spec.rb +++ b/spec/models/better_together/email_address_spec.rb @@ -2,10 +2,142 @@ require 'rails_helper' -module BetterTogether - RSpec.describe EmailAddress do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be +RSpec.describe BetterTogether::EmailAddress do + describe 'factory' do + it 'creates a valid email address' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + email_address = create(:email_address, contact_detail: contact_detail) + expect(email_address).to be_valid + end + + it 'generates unique email addresses' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + email1 = create(:email_address, contact_detail: contact_detail, primary_flag: true) + email2 = create(:email_address, contact_detail: contact_detail, primary_flag: false) + expect(email1.email).not_to eq(email2.email) + end + end + + describe 'associations' do + it { is_expected.to belong_to(:contact_detail).class_name('BetterTogether::ContactDetail').touch(true) } + end + + describe 'validations' do + describe 'email presence' do + it 'requires email to be present' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + email_address = build(:email_address, contact_detail: contact_detail, email: nil) + expect(email_address).not_to be_valid + expect(email_address.errors[:email]).to include("can't be blank") + end + end + + describe 'email format' do + it 'accepts valid email formats' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + valid_emails = [ + 'user@example.com', + 'first.last@example.com', + 'user+tag@example.co.uk', + 'test_email@subdomain.example.com' + ] + + valid_emails.each do |email| + email_address = build(:email_address, contact_detail: contact_detail, email: email) + expect(email_address).to be_valid, "Expected #{email} to be valid" + end + end + + it 'rejects invalid email formats' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + invalid_emails = [ + 'invalid', + '@example.com', + 'user@', + 'user @example.com' + ] + + invalid_emails.each do |email| + email_address = build(:email_address, contact_detail: contact_detail, email: email) + expect(email_address).not_to be_valid, "Expected #{email} to be invalid" + expect(email_address.errors[:email]).to be_present + end + end + end + end + + describe 'PrimaryFlag concern' do + it 'includes PrimaryFlag behavior' do + expect(described_class.included_modules).to include(BetterTogether::PrimaryFlag) + end + + it 'allows setting primary_flag' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + email_address = create(:email_address, contact_detail: contact_detail, primary_flag: true) + expect(email_address.primary_flag).to be true + end + + it 'scopes primary flag by contact_detail_id' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + email1 = create(:email_address, contact_detail: contact_detail, primary_flag: true) + email2 = create(:email_address, contact_detail: contact_detail, primary_flag: false) + + expect(email1.primary_flag).to be true + expect(email2.primary_flag).to be false + end + end + + describe 'Privacy concern' do + it 'includes Privacy behavior' do + expect(described_class.included_modules).to include(BetterTogether::Privacy) + end + + it 'allows setting privacy level' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + email_address = create(:email_address, contact_detail: contact_detail, privacy: 'private') + expect(email_address.privacy).to eq('private') + end + end + + describe 'Labelable concern' do + it 'includes Labelable behavior' do + expect(described_class.included_modules).to include(BetterTogether::Labelable) + end + + it 'accepts valid labels' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + + BetterTogether::EmailAddress::LABELS.each do |label| + email_address = build(:email_address, contact_detail: contact_detail, label: label.to_s) + expect(email_address).to be_valid + end + end + + it 'defines expected label constants' do + expect(BetterTogether::EmailAddress::LABELS).to include(:personal, :work, :school, :other) + end + end + + describe 'touch association' do + it 'touches contact_detail on update' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + email_address = create(:email_address, contact_detail: contact_detail) + + original_updated_at = contact_detail.updated_at + sleep 0.01 + email_address.update!(email: 'newemail@example.com') + + expect(contact_detail.reload.updated_at).to be > original_updated_at end end end diff --git a/spec/models/better_together/event_category_spec.rb b/spec/models/better_together/event_category_spec.rb index 1dbe0d640..90befb573 100644 --- a/spec/models/better_together/event_category_spec.rb +++ b/spec/models/better_together/event_category_spec.rb @@ -4,8 +4,106 @@ module BetterTogether RSpec.describe EventCategory do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid event category' do + event_category = build(:event_category) + expect(event_category).to be_valid + end + end + + describe 'inheritance' do + it 'inherits from Category' do + expect(described_class.superclass).to eq(Category) + end + + it 'uses STI with type column' do + event_category = create(:event_category) + expect(event_category.type).to eq('BetterTogether::EventCategory') + end + + it 'can be queried through Category' do + event_category = create(:event_category) + expect(Category.find(event_category.id)).to eq(event_category) + end + end + + describe 'associations' do + it { is_expected.to have_many(:categorizations).dependent(:destroy) } + it { is_expected.to have_many(:events).through(:categorizations) } + end + + describe 'validations' do + it { is_expected.to validate_presence_of(:name) } + it { is_expected.to validate_presence_of(:type) } + end + + describe 'translatable attributes' do + it 'has translatable name' do + event_category = create(:event_category, name: 'English Name') + expect(event_category.name).to eq('English Name') + end + + it 'has translatable description' do + event_category = create(:event_category, description: 'Test Description') + expect(event_category.description).to be_present + end + end + + describe '#as_category' do + it 'returns instance as base Category class' do + event_category = create(:event_category) + as_category = event_category.as_category + + expect(as_category).to be_a(Category) + expect(as_category.id).to eq(event_category.id) + end + end + + describe 'event categorization' do + it 'can categorize events' do + event_category = create(:event_category) + event = create(:event) + + categorization = create(:categorization, + category: event_category, + categorizable: event) + + expect(event_category.events).to include(event) + expect(event_category.categorizations).to include(categorization) + end + + it 'allows multiple events in one category' do + event_category = create(:event_category) + event1 = create(:event) + event2 = create(:event) + + create(:categorization, category: event_category, categorizable: event1) + create(:categorization, category: event_category, categorizable: event2) + + expect(event_category.events.count).to eq(2) + expect(event_category.events).to contain_exactly(event1, event2) + end + + it 'removes categorizations when category is destroyed' do + event_category = create(:event_category) + event = create(:event) + create(:categorization, + category: event_category, + categorizable: event) + + expect { event_category.destroy }.to change(Categorization, :count).by(-1) + end + end + + describe 'identifier behavior' do + it 'generates unique identifiers' do + cat1 = create(:event_category) + cat2 = create(:event_category) + + expect(cat1.identifier).to be_present + expect(cat2.identifier).to be_present + expect(cat1.identifier).not_to eq(cat2.identifier) + end end end end diff --git a/spec/models/better_together/geography/continent_spec.rb b/spec/models/better_together/geography/continent_spec.rb index 61631548d..b368674d5 100644 --- a/spec/models/better_together/geography/continent_spec.rb +++ b/spec/models/better_together/geography/continent_spec.rb @@ -3,9 +3,114 @@ require 'rails_helper' module BetterTogether - RSpec.describe ::BetterTogether::Geography::Continent do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + RSpec.describe Geography::Continent do + subject(:continent) { build(:better_together_geography_continent) } + + describe 'concerns' do + it 'includes Geospatial::One' do + expect(described_class.ancestors).to include(BetterTogether::Geography::Geospatial::One) + end + + it 'includes Identifier' do + expect(described_class.ancestors).to include(BetterTogether::Identifier) + end + + it 'includes Protected' do + expect(described_class.ancestors).to include(BetterTogether::Protected) + end + + it 'includes PrimaryCommunity' do + expect(described_class.ancestors).to include(BetterTogether::PrimaryCommunity) + end + end + + describe 'database' do + it { is_expected.to have_db_column(:id).of_type(:uuid) } + it { is_expected.to have_db_column(:identifier).of_type(:string) } + it { is_expected.to have_db_column(:protected).of_type(:boolean) } + it { is_expected.to have_db_column(:community_id).of_type(:uuid) } + it { is_expected.to have_db_column(:lock_version).of_type(:integer) } + it { is_expected.to have_db_column(:created_at).of_type(:datetime) } + it { is_expected.to have_db_column(:updated_at).of_type(:datetime) } + end + + describe 'associations' do + subject(:continent) { build(:better_together_geography_continent) } + + it { is_expected.to belong_to(:community).class_name('BetterTogether::Community') } + + it do + expect(continent).to have_many(:country_continents) + .class_name('BetterTogether::Geography::CountryContinent') + .dependent(:destroy) + end + + it do + expect(continent).to have_many(:countries) + .through(:country_continents) + .class_name('BetterTogether::Geography::Country') + end + end + + describe 'translations' do + it 'translates name' do + continent.name = 'North America' + Mobility.with_locale(:es) do + continent.name = 'América del Norte' + end + expect(continent.name).to eq('North America') + Mobility.with_locale(:es) do + expect(continent.name).to eq('América del Norte') + end + end + + it 'translates description' do + continent.description = 'A large continent' + Mobility.with_locale(:es) do + continent.description = 'Un gran continente' + end + expect(continent.description).to eq('A large continent') + Mobility.with_locale(:es) do + expect(continent.description).to eq('Un gran continente') + end + end + + it 'translates slug' do + continent.identifier = 'north-america' + continent.save! + expect(continent.slug).to eq('north-america') + Mobility.with_locale(:es) do + continent.slug = 'america-del-norte' + continent.save! + expect(continent.slug).to eq('america-del-norte') + end + end + end + + describe 'validations' do + it { is_expected.to validate_presence_of(:name) } + + it 'validates identifier uniqueness case-insensitively' do + create(:better_together_geography_continent, identifier: 'test-continent') + duplicate = build(:better_together_geography_continent, identifier: 'TEST-CONTINENT') + expect(duplicate).not_to be_valid + expect(duplicate.errors[:identifier]).to include('has already been taken') + end + end + + describe '#to_s' do + it 'returns the continent name' do + continent.name = 'Europe' + expect(continent.to_s).to eq('Europe') + end + end + + describe 'identifier generation' do + it 'generates identifier from slug if not provided' do + continent.name = 'South America' + continent.save! + expect(continent.identifier).to be_present + end end end end diff --git a/spec/models/better_together/geography/country_spec.rb b/spec/models/better_together/geography/country_spec.rb index 48ac9f313..1b0e6a052 100644 --- a/spec/models/better_together/geography/country_spec.rb +++ b/spec/models/better_together/geography/country_spec.rb @@ -3,9 +3,120 @@ require 'rails_helper' module BetterTogether - RSpec.describe ::BetterTogether::Geography::Country do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + RSpec.describe Geography::Country do + subject(:country) { build(:better_together_geography_country) } + + describe 'concerns' do + it 'includes Geospatial::One' do + expect(described_class.ancestors).to include(BetterTogether::Geography::Geospatial::One) + end + + it 'includes Identifier' do + expect(described_class.ancestors).to include(BetterTogether::Identifier) + end + + it 'includes Protected' do + expect(described_class.ancestors).to include(BetterTogether::Protected) + end + + it 'includes PrimaryCommunity' do + expect(described_class.ancestors).to include(BetterTogether::PrimaryCommunity) + end + end + + describe 'database' do + it { is_expected.to have_db_column(:id).of_type(:uuid) } + it { is_expected.to have_db_column(:identifier).of_type(:string) } + it { is_expected.to have_db_column(:protected).of_type(:boolean) } + it { is_expected.to have_db_column(:community_id).of_type(:uuid) } + it { is_expected.to have_db_column(:lock_version).of_type(:integer) } + it { is_expected.to have_db_column(:created_at).of_type(:datetime) } + it { is_expected.to have_db_column(:updated_at).of_type(:datetime) } + end + + describe 'associations' do + subject(:country) { build(:better_together_geography_country) } + + it { is_expected.to belong_to(:community).class_name('BetterTogether::Community') } + + it do + expect(country).to have_many(:country_continents) + .class_name('BetterTogether::Geography::CountryContinent') + .dependent(:destroy) + end + + it do + expect(country).to have_many(:continents) + .through(:country_continents) + .class_name('BetterTogether::Geography::Continent') + end + + it do + expect(country).to have_many(:states) + .class_name('BetterTogether::Geography::State') + .dependent(:nullify) + end + end + + describe 'translations' do + it 'translates name' do + country.name = 'United States' + Mobility.with_locale(:es) do + country.name = 'Estados Unidos' + end + expect(country.name).to eq('United States') + Mobility.with_locale(:es) do + expect(country.name).to eq('Estados Unidos') + end + end + + it 'translates description' do + country.description = 'A large country' + Mobility.with_locale(:es) do + country.description = 'Un gran país' + end + expect(country.description).to eq('A large country') + Mobility.with_locale(:es) do + expect(country.description).to eq('Un gran país') + end + end + + it 'translates slug' do + country.identifier = 'united-states' + country.save! + expect(country.slug).to eq('united-states') + Mobility.with_locale(:es) do + country.slug = 'estados-unidos' + country.save! + expect(country.slug).to eq('estados-unidos') + end + end + end + + describe 'validations' do + it { is_expected.to validate_presence_of(:name) } + + it 'validates identifier uniqueness case-insensitively' do + create(:better_together_geography_country, identifier: 'test-country') + duplicate = build(:better_together_geography_country, identifier: 'TEST-COUNTRY') + expect(duplicate).not_to be_valid + expect(duplicate.errors[:identifier]).to include('has already been taken') + end + end + + describe '#to_s' do + it 'returns the country name' do + country.name = 'Canada' + expect(country.to_s).to eq('Canada') + end + end + + describe 'identifier generation' do + it 'generates identifier from slug if not provided' do + country.name = 'Mexico' + country.save! + expect(country.identifier).to be_present + end end end end diff --git a/spec/models/better_together/geography/map_spec.rb b/spec/models/better_together/geography/map_spec.rb index 7c8d60387..2a22ee80f 100644 --- a/spec/models/better_together/geography/map_spec.rb +++ b/spec/models/better_together/geography/map_spec.rb @@ -4,8 +4,120 @@ module BetterTogether RSpec.describe Geography::Map do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + subject(:map) { build(:better_together_geography_map) } + + describe 'concerns' do + it 'includes Creatable' do + expect(described_class.ancestors).to include(BetterTogether::Creatable) + end + + it 'includes FriendlySlug' do + expect(described_class.ancestors).to include(BetterTogether::FriendlySlug) + end + + it 'includes Identifier' do + expect(described_class.ancestors).to include(BetterTogether::Identifier) + end + + it 'includes Privacy' do + expect(described_class.ancestors).to include(BetterTogether::Privacy) + end + + it 'includes Protected' do + expect(described_class.ancestors).to include(BetterTogether::Protected) + end + + it 'includes Viewable' do + expect(described_class.ancestors).to include(BetterTogether::Viewable) + end + end + + describe 'database' do + it { is_expected.to have_db_column(:id).of_type(:uuid) } + it { is_expected.to have_db_column(:identifier).of_type(:string) } + it { is_expected.to have_db_column(:zoom).of_type(:integer) } + it { is_expected.to have_db_column(:protected).of_type(:boolean) } + it { is_expected.to have_db_column(:creator_id).of_type(:uuid) } + it { is_expected.to have_db_column(:privacy).of_type(:string) } + it { is_expected.to have_db_column(:mappable_id).of_type(:uuid) } + it { is_expected.to have_db_column(:mappable_type).of_type(:string) } + it { is_expected.to have_db_column(:lock_version).of_type(:integer) } + it { is_expected.to have_db_column(:created_at).of_type(:datetime) } + it { is_expected.to have_db_column(:updated_at).of_type(:datetime) } + end + + describe 'associations' do + it { is_expected.to belong_to(:creator).class_name('BetterTogether::Person') } + it { is_expected.to belong_to(:mappable).optional } + end + + describe 'translations' do + # NOTE: This test will pass after running the title migration + # The type: :string parameter ensures new records use string_translations table + it 'translates title' do + skip 'Mobility key-value backend does not support locale switching for unsaved records' + + map.title = 'World Map' + expect(map.title).to eq('World Map') + + Mobility.with_locale(:es) do + map.title = 'Mapa del Mundo' + expect(map.title).to eq('Mapa del Mundo') + end + + # After exiting the es locale block, should still be World Map in default locale + expect(map.title).to eq('World Map') + end + + it 'translates description with Action Text' do + map.description = 'A comprehensive map
' + expect(map.description).to be_a(ActionText::RichText) + end + end + + describe 'validations' do + it { is_expected.to validate_numericality_of(:zoom).only_integer.is_greater_than(0) } + + it 'validates center presence' do + # Since center has a default_center fallback in the getter, + # we verify the validation exists rather than testing the fallback behavior + expect(described_class.validators_on(:center).map(&:class)).to include(ActiveRecord::Validations::PresenceValidator) + end + end + + describe 'default center' do + it 'sets default center before validation on create' do + new_map = build(:better_together_geography_map, center: nil) + new_map.valid? + expect(new_map.center).to be_present + end + + it 'uses ENV defaults or fallback coordinates' do + new_map = build(:better_together_geography_map, center: nil) + default = new_map.default_center + expect(default).to be_a(RGeo::Geographic::SphericalPointImpl) + end + end + + describe '#center' do + it 'returns set center if present' do + factory = RGeo::Geographic.spherical_factory(srid: 4326) + custom_center = factory.point(-122.4194, 37.7749) + map.center = custom_center + expect(map.center).to eq(custom_center) + end + + it 'returns default_center if not set' do + map.center = nil + expect(map.center).to eq(map.default_center) + end + end + + describe '.permitted_attributes' do + it 'includes map-specific attributes' do + attrs = described_class.permitted_attributes + expect(attrs).to include(:type, :zoom, :center) + end end end end diff --git a/spec/models/better_together/geography/region_spec.rb b/spec/models/better_together/geography/region_spec.rb index d8a2de550..fdcbf484e 100644 --- a/spec/models/better_together/geography/region_spec.rb +++ b/spec/models/better_together/geography/region_spec.rb @@ -3,9 +3,112 @@ require 'rails_helper' module BetterTogether - RSpec.describe ::BetterTogether::Geography::Region do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + RSpec.describe Geography::Region do + subject(:region) { build(:better_together_geography_region) } + + describe 'concerns' do + it 'includes Geospatial::One' do + expect(described_class.ancestors).to include(BetterTogether::Geography::Geospatial::One) + end + + it 'includes Identifier' do + expect(described_class.ancestors).to include(BetterTogether::Identifier) + end + + it 'includes Protected' do + expect(described_class.ancestors).to include(BetterTogether::Protected) + end + + it 'includes PrimaryCommunity' do + expect(described_class.ancestors).to include(BetterTogether::PrimaryCommunity) + end + end + + describe 'database' do + it { is_expected.to have_db_column(:id).of_type(:uuid) } + it { is_expected.to have_db_column(:identifier).of_type(:string) } + it { is_expected.to have_db_column(:protected).of_type(:boolean) } + it { is_expected.to have_db_column(:community_id).of_type(:uuid) } + it { is_expected.to have_db_column(:country_id).of_type(:uuid) } + it { is_expected.to have_db_column(:state_id).of_type(:uuid) } + it { is_expected.to have_db_column(:lock_version).of_type(:integer) } + it { is_expected.to have_db_column(:created_at).of_type(:datetime) } + it { is_expected.to have_db_column(:updated_at).of_type(:datetime) } + end + + describe 'associations' do + subject(:region) { build(:better_together_geography_region) } + + it { is_expected.to belong_to(:community).class_name('BetterTogether::Community') } + it { is_expected.to belong_to(:country).class_name('BetterTogether::Geography::Country').optional } + it { is_expected.to belong_to(:state).class_name('BetterTogether::Geography::State').optional } + + it do + expect(region).to have_many(:region_settlements) + .class_name('BetterTogether::Geography::RegionSettlement') + end + + it do + expect(region).to have_many(:settlements) + .through(:region_settlements) + .source(:settlement) + end + end + + describe 'translations' do + it 'translates name' do + region.name = 'Bay Area' + Mobility.with_locale(:es) do + region.name = 'Área de la Bahía' + end + expect(region.name).to eq('Bay Area') + Mobility.with_locale(:es) do + expect(region.name).to eq('Área de la Bahía') + end + end + + it 'translates description' do + region.description = 'A metropolitan region' + Mobility.with_locale(:es) do + region.description = 'Una región metropolitana' + end + expect(region.description).to eq('A metropolitan region') + Mobility.with_locale(:es) do + expect(region.description).to eq('Una región metropolitana') + end + end + end + + describe 'validations' do + it { is_expected.to validate_presence_of(:name) } + + it 'validates identifier uniqueness case-insensitively' do + create(:better_together_geography_region, identifier: 'test-region') + duplicate = build(:better_together_geography_region, identifier: 'TEST-REGION') + expect(duplicate).not_to be_valid + expect(duplicate.errors[:identifier]).to include('has already been taken') + end + end + + describe '#to_s' do + it 'returns the region name' do + region.name = 'Silicon Valley' + expect(region.to_s).to eq('Silicon Valley') + end + end + + describe 'optional associations' do + it 'can be created without a country' do + region.country = nil + region.save! + expect(region).to be_persisted + end + + it 'can be created without a state' do + region.state = nil + region.save! + expect(region).to be_persisted + end end end end diff --git a/spec/models/better_together/geography/settlement_spec.rb b/spec/models/better_together/geography/settlement_spec.rb index cc6184767..35ba259f8 100644 --- a/spec/models/better_together/geography/settlement_spec.rb +++ b/spec/models/better_together/geography/settlement_spec.rb @@ -3,9 +3,112 @@ require 'rails_helper' module BetterTogether - RSpec.describe ::BetterTogether::Geography::Settlement do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + RSpec.describe Geography::Settlement do + subject(:settlement) { build(:better_together_geography_settlement) } + + describe 'concerns' do + it 'includes Geospatial::One' do + expect(described_class.ancestors).to include(BetterTogether::Geography::Geospatial::One) + end + + it 'includes Identifier' do + expect(described_class.ancestors).to include(BetterTogether::Identifier) + end + + it 'includes Protected' do + expect(described_class.ancestors).to include(BetterTogether::Protected) + end + + it 'includes PrimaryCommunity' do + expect(described_class.ancestors).to include(BetterTogether::PrimaryCommunity) + end + end + + describe 'database' do + it { is_expected.to have_db_column(:id).of_type(:uuid) } + it { is_expected.to have_db_column(:identifier).of_type(:string) } + it { is_expected.to have_db_column(:protected).of_type(:boolean) } + it { is_expected.to have_db_column(:community_id).of_type(:uuid) } + it { is_expected.to have_db_column(:country_id).of_type(:uuid) } + it { is_expected.to have_db_column(:state_id).of_type(:uuid) } + it { is_expected.to have_db_column(:lock_version).of_type(:integer) } + it { is_expected.to have_db_column(:created_at).of_type(:datetime) } + it { is_expected.to have_db_column(:updated_at).of_type(:datetime) } + end + + describe 'associations' do + subject(:settlement) { build(:better_together_geography_settlement) } + + it { is_expected.to belong_to(:community).class_name('BetterTogether::Community') } + it { is_expected.to belong_to(:country).class_name('BetterTogether::Geography::Country').optional } + it { is_expected.to belong_to(:state).class_name('BetterTogether::Geography::State').optional } + + it do + expect(settlement).to have_many(:region_settlements) + .class_name('BetterTogether::Geography::RegionSettlement') + end + + it do + expect(settlement).to have_many(:regions) + .through(:region_settlements) + .source(:region) + end + end + + describe 'translations' do + it 'translates name' do + settlement.name = 'San Francisco' + Mobility.with_locale(:es) do + settlement.name = 'San Francisco' + end + expect(settlement.name).to eq('San Francisco') + Mobility.with_locale(:es) do + expect(settlement.name).to eq('San Francisco') + end + end + + it 'translates description' do + settlement.description = 'A coastal city' + Mobility.with_locale(:es) do + settlement.description = 'Una ciudad costera' + end + expect(settlement.description).to eq('A coastal city') + Mobility.with_locale(:es) do + expect(settlement.description).to eq('Una ciudad costera') + end + end + end + + describe 'validations' do + it { is_expected.to validate_presence_of(:name) } + + it 'validates identifier uniqueness case-insensitively' do + create(:better_together_geography_settlement, identifier: 'test-settlement') + duplicate = build(:better_together_geography_settlement, identifier: 'TEST-SETTLEMENT') + expect(duplicate).not_to be_valid + expect(duplicate.errors[:identifier]).to include('has already been taken') + end + end + + describe '#to_s' do + it 'returns the settlement name' do + settlement.name = 'Los Angeles' + expect(settlement.to_s).to eq('Los Angeles') + end + end + + describe 'optional associations' do + it 'can be created without a country' do + settlement.country = nil + settlement.save! + expect(settlement).to be_persisted + end + + it 'can be created without a state' do + settlement.state = nil + settlement.save! + expect(settlement).to be_persisted + end end end end diff --git a/spec/models/better_together/geography/state_spec.rb b/spec/models/better_together/geography/state_spec.rb index 6ceb19328..27603470a 100644 --- a/spec/models/better_together/geography/state_spec.rb +++ b/spec/models/better_together/geography/state_spec.rb @@ -3,9 +3,114 @@ require 'rails_helper' module BetterTogether - RSpec.describe ::BetterTogether::Geography::State do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + RSpec.describe Geography::State do + subject(:state) { build(:better_together_geography_state) } + + describe 'concerns' do + it 'includes Geospatial::One' do + expect(described_class.ancestors).to include(BetterTogether::Geography::Geospatial::One) + end + + it 'includes Identifier' do + expect(described_class.ancestors).to include(BetterTogether::Identifier) + end + + it 'includes Protected' do + expect(described_class.ancestors).to include(BetterTogether::Protected) + end + + it 'includes PrimaryCommunity' do + expect(described_class.ancestors).to include(BetterTogether::PrimaryCommunity) + end + end + + describe 'database' do + it { is_expected.to have_db_column(:id).of_type(:uuid) } + it { is_expected.to have_db_column(:identifier).of_type(:string) } + it { is_expected.to have_db_column(:protected).of_type(:boolean) } + it { is_expected.to have_db_column(:community_id).of_type(:uuid) } + it { is_expected.to have_db_column(:country_id).of_type(:uuid) } + it { is_expected.to have_db_column(:lock_version).of_type(:integer) } + it { is_expected.to have_db_column(:created_at).of_type(:datetime) } + it { is_expected.to have_db_column(:updated_at).of_type(:datetime) } + end + + describe 'associations' do + subject(:state) { build(:better_together_geography_state) } + + it { is_expected.to belong_to(:community).class_name('BetterTogether::Community') } + it { is_expected.to belong_to(:country).class_name('BetterTogether::Geography::Country') } + + it do + expect(state).to have_many(:regions) + .class_name('BetterTogether::Geography::Region') + end + + it do + expect(state).to have_many(:settlements) + .class_name('BetterTogether::Geography::Settlement') + end + end + + describe 'translations' do + it 'translates name' do + state.name = 'California' + Mobility.with_locale(:es) do + state.name = 'California' + end + expect(state.name).to eq('California') + Mobility.with_locale(:es) do + expect(state.name).to eq('California') + end + end + + it 'translates description' do + state.description = 'A western state' + Mobility.with_locale(:es) do + state.description = 'Un estado occidental' + end + expect(state.description).to eq('A western state') + Mobility.with_locale(:es) do + expect(state.description).to eq('Un estado occidental') + end + end + + it 'translates slug' do + state.identifier = 'california' + state.save! + expect(state.slug).to eq('california') + Mobility.with_locale(:es) do + state.slug = 'california-es' + state.save! + expect(state.slug).to eq('california-es') + end + end + end + + describe 'validations' do + it { is_expected.to validate_presence_of(:name) } + + it 'validates identifier uniqueness case-insensitively' do + create(:better_together_geography_state, identifier: 'test-state') + duplicate = build(:better_together_geography_state, identifier: 'TEST-STATE') + expect(duplicate).not_to be_valid + expect(duplicate.errors[:identifier]).to include('has already been taken') + end + end + + describe '#to_s' do + it 'returns the state name' do + state.name = 'Texas' + expect(state.to_s).to eq('Texas') + end + end + + describe 'identifier generation' do + it 'generates identifier from slug if not provided' do + state.name = 'New York' + state.save! + expect(state.identifier).to be_present + end end end end diff --git a/spec/models/better_together/jwt_denylist_spec.rb b/spec/models/better_together/jwt_denylist_spec.rb index c1e4fea92..cf42c3c95 100644 --- a/spec/models/better_together/jwt_denylist_spec.rb +++ b/spec/models/better_together/jwt_denylist_spec.rb @@ -4,8 +4,90 @@ module BetterTogether RSpec.describe JwtDenylist do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid jwt denylist entry' do + entry = build(:jwt_denylist) + expect(entry).to be_valid + end + + it 'creates entries with different expiration times' do + %i[expired recently_expired expires_soon long_lived].each do |trait| + entry = build(:jwt_denylist, trait) + expect(entry).to be_valid + end + end + end + + describe 'devise jwt integration' do + it 'includes Devise::JWT::RevocationStrategies::Denylist' do + expect(described_class.included_modules).to include(Devise::JWT::RevocationStrategies::Denylist) + end + + it 'has correct table name' do + expect(described_class.table_name).to eq('better_together_jwt_denylists') + end + end + + describe 'database schema' do + it 'has jti column' do + entry = create(:jwt_denylist) + expect(entry).to respond_to(:jti) + expect(entry.jti).to be_present + end + + it 'has exp column' do + entry = create(:jwt_denylist) + expect(entry).to respond_to(:exp) + expect(entry.exp).to be_present + end + + it 'has standard bt_table columns' do + entry = create(:jwt_denylist) + expect(entry).to respond_to(:id) + expect(entry).to respond_to(:lock_version) + expect(entry).to respond_to(:created_at) + expect(entry).to respond_to(:updated_at) + end + end + + describe 'token revocation' do + it 'stores unique jti values' do + jti1 = SecureRandom.uuid + jti2 = SecureRandom.uuid + + entry1 = create(:jwt_denylist, jti: jti1) + entry2 = create(:jwt_denylist, jti: jti2) + + expect(entry1.jti).not_to eq(entry2.jti) + end + + it 'stores expiration time' do + exp_time = 2.hours.from_now + entry = create(:jwt_denylist, exp: exp_time) + + expect(entry.exp).to be_within(1.second).of(exp_time) + end + + it 'can store expired tokens' do + entry = create(:jwt_denylist, :expired) + + expect(entry.exp).to be < Time.current + end + end + + describe 'queries' do + it 'can find entries by jti' do + jti = SecureRandom.uuid + entry = create(:jwt_denylist, jti: jti) + + found = described_class.find_by(jti: jti) + expect(found).to eq(entry) + end + + it 'returns nil for non-existent jti' do + found = described_class.find_by(jti: 'non-existent-jti') + expect(found).to be_nil + end end end end diff --git a/spec/models/better_together/message_spec.rb b/spec/models/better_together/message_spec.rb index 3e719c927..34ffc8686 100644 --- a/spec/models/better_together/message_spec.rb +++ b/spec/models/better_together/message_spec.rb @@ -2,10 +2,58 @@ require 'rails_helper' -module BetterTogether - RSpec.describe Message do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be +RSpec.describe BetterTogether::Message do + describe 'Factory' do + it 'has a valid factory' do + message = build(:message) + expect(message).to be_valid + end + + it 'creates a message with content' do + message = build(:message, content: 'Test message') + message.save!(validate: false) # Skip validation to avoid factory callback issues initially + expect(message.reload.content.to_plain_text).to include('Test message') + end + end + + describe 'Associations' do + it { is_expected.to belong_to(:conversation).touch(true) } + it { is_expected.to belong_to(:sender).class_name('BetterTogether::Person') } + end + + describe 'Validations' do + it 'requires content' do + message = build(:message, content: nil) + expect(message).not_to be_valid + expect(message.errors[:content]).to include("can't be blank") + end + + it 'accepts valid content' do + message = build(:message, content: 'Valid message') + expect(message).to be_valid + end + end + + describe 'Action Text Integration' do + it 'has rich text content' do + message = build(:message, content: 'Rich text') + message.save!(validate: false) + expect(message.content).to be_a(ActionText::RichText) + end + + it 'converts content to plain text' do + message = build(:message, content: 'Rich text
') + message.save!(validate: false) + plain_text = message.reload.content.to_plain_text.strip + expect(plain_text).to eq('Rich text') + end + end + + describe 'Class Methods' do + describe '.permitted_attributes' do + it 'returns an array with expected attributes' do + expect(described_class.permitted_attributes).to match_array(%i[id content _destroy]) + end end end end diff --git a/spec/models/better_together/metrics/download_spec.rb b/spec/models/better_together/metrics/download_spec.rb index 507f7b3c9..25518e3b2 100644 --- a/spec/models/better_together/metrics/download_spec.rb +++ b/spec/models/better_together/metrics/download_spec.rb @@ -4,8 +4,91 @@ module BetterTogether RSpec.describe Metrics::Download do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid download' do + community = create(:community) + download = create(:metrics_download, + downloadable: community, + file_name: 'report.pdf', + file_type: 'application/pdf', + file_size: 2048, + downloaded_at: Time.current, + locale: 'en') + expect(download).to be_valid + expect(download.file_name).to eq('report.pdf') + end + end + + describe 'associations' do + it { is_expected.to belong_to(:downloadable) } + end + + describe 'validations' do + describe 'file_name' do + it 'requires file_name to be present' do + download = build(:metrics_download, file_name: nil) + expect(download).not_to be_valid + expect(download.errors[:file_name]).to include("can't be blank") + end + end + + describe 'file_type' do + it 'requires file_type to be present' do + download = build(:metrics_download, file_type: nil) + expect(download).not_to be_valid + expect(download.errors[:file_type]).to include("can't be blank") + end + end + + describe 'file_size' do + it 'requires file_size to be present' do + download = build(:metrics_download, file_size: nil) + expect(download).not_to be_valid + expect(download.errors[:file_size]).to include("can't be blank") + end + end + + describe 'downloaded_at' do + it 'requires downloaded_at to be present' do + download = build(:metrics_download, downloaded_at: nil) + expect(download).not_to be_valid + expect(download.errors[:downloaded_at]).to include("can't be blank") + end + end + + describe 'locale' do + it 'requires locale to be present' do + download = build(:metrics_download, locale: nil) + expect(download).not_to be_valid + expect(download.errors[:locale]).to include("can't be blank") + end + + it 'validates locale is in available locales' do + download = build(:metrics_download, locale: 'invalid') + expect(download).not_to be_valid + expect(download.errors[:locale]).to include('is not included in the list') + end + + it 'accepts valid locales' do + I18n.available_locales.each do |locale| + download = build(:metrics_download, locale: locale.to_s) + expect(download).to be_valid, "Expected #{locale} to be valid" + end + end + end + end + + describe 'file tracking' do + it 'tracks file metadata' do + download = create(:metrics_download, + file_name: 'annual_report.pdf', + file_type: 'application/pdf', + file_size: 4096) + + expect(download.file_name).to eq('annual_report.pdf') + expect(download.file_type).to eq('application/pdf') + expect(download.file_size).to eq(4096) + end end end end diff --git a/spec/models/better_together/metrics/link_click_report_spec.rb b/spec/models/better_together/metrics/link_click_report_spec.rb index c591a7b2c..d4333b46f 100644 --- a/spec/models/better_together/metrics/link_click_report_spec.rb +++ b/spec/models/better_together/metrics/link_click_report_spec.rb @@ -4,8 +4,57 @@ module BetterTogether RSpec.describe Metrics::LinkClickReport do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid link click report' do + report = build(:metrics_link_click_report, file_format: 'csv') + expect(report).to be_valid + expect(report.file_format).to eq('csv') + end + end + + describe 'Active Storage attachments' do + it 'has one attached report_file' do + report = build(:metrics_link_click_report) + expect(report).to respond_to(:report_file) + end + end + + describe 'validations' do + describe 'file_format' do + it 'requires file_format to be present' do + report = build(:metrics_link_click_report, file_format: nil) + expect(report).not_to be_valid + expect(report.errors[:file_format]).to include("can't be blank") + end + end + end + + describe 'attributes' do + it 'has filters as jsonb with default empty hash' do + report = build(:metrics_link_click_report) + expect(report.filters).to eq({}) + end + + it 'accepts custom filters' do + filters = { 'from_date' => '2025-01-01', 'to_date' => '2025-12-31' } + report = build(:metrics_link_click_report, filters: filters) + expect(report.filters).to eq(filters) + end + end + + describe 'callbacks' do + it 'responds to generate_report!' do + report = build(:metrics_link_click_report) + expect(report).to respond_to(:generate_report!) + end + end + + describe 'report generation' do + it 'generates report data before creation' do + report = build(:metrics_link_click_report) + expect(report).to receive(:generate_report!) + report.save + end end end end diff --git a/spec/models/better_together/metrics/page_view_report_spec.rb b/spec/models/better_together/metrics/page_view_report_spec.rb index 7076e0edc..72f08b302 100644 --- a/spec/models/better_together/metrics/page_view_report_spec.rb +++ b/spec/models/better_together/metrics/page_view_report_spec.rb @@ -4,8 +4,62 @@ module BetterTogether RSpec.describe Metrics::PageViewReport do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid page view report' do + report = build(:metrics_page_view_report, file_format: 'csv') + expect(report).to be_valid + expect(report.file_format).to eq('csv') + end + end + + describe 'Active Storage attachments' do + it 'has one attached report_file' do + report = build(:metrics_page_view_report) + expect(report).to respond_to(:report_file) + end + end + + describe 'validations' do + describe 'file_format' do + it 'requires file_format to be present' do + report = build(:metrics_page_view_report, file_format: nil) + expect(report).not_to be_valid + expect(report.errors[:file_format]).to include("can't be blank") + end + end + end + + describe 'attributes' do + it 'has filters as jsonb with default empty hash' do + report = build(:metrics_page_view_report) + expect(report.filters).to eq({}) + end + + it 'accepts custom filters' do + filters = { 'from_date' => '2025-01-01', 'to_date' => '2025-12-31', 'filter_pageable_type' => 'Community' } + report = build(:metrics_page_view_report, filters: filters) + expect(report.filters).to eq(filters) + end + + it 'has sort_by_total_views attribute' do + report = build(:metrics_page_view_report, sort_by_total_views: true) + expect(report.sort_by_total_views).to be true + end + end + + describe 'callbacks' do + it 'responds to generate_report!' do + report = build(:metrics_page_view_report) + expect(report).to respond_to(:generate_report!) + end + end + + describe 'report generation' do + it 'generates report data before creation' do + report = build(:metrics_page_view_report) + expect(report).to receive(:generate_report!) + report.save + end end end end diff --git a/spec/models/better_together/metrics/share_spec.rb b/spec/models/better_together/metrics/share_spec.rb index 9ab90154e..c08cd83f4 100644 --- a/spec/models/better_together/metrics/share_spec.rb +++ b/spec/models/better_together/metrics/share_spec.rb @@ -4,8 +4,106 @@ module BetterTogether RSpec.describe Metrics::Share do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid share' do + community = create(:community) + share = create(:metrics_share, + shareable: community, + platform: 'facebook', + url: 'https://facebook.com/share', + shared_at: Time.current, + locale: 'en') + expect(share).to be_valid + expect(share.platform).to eq('facebook') + end + end + + describe 'associations' do + it { is_expected.to belong_to(:shareable).optional } + end + + describe 'validations' do + describe 'platform' do + it 'requires platform to be present' do + share = build(:metrics_share, platform: nil) + expect(share).not_to be_valid + expect(share.errors[:platform]).to include("can't be blank") + end + + it 'validates platform is in allowed list' do + share = build(:metrics_share, platform: 'invalid_platform') + expect(share).not_to be_valid + expect(share.errors[:platform]).to include('is not included in the list') + end + + it 'accepts valid platforms' do + valid_platforms = %w[facebook bluesky linkedin pinterest reddit whatsapp] + + valid_platforms.each do |platform| + share = build(:metrics_share, platform: platform) + expect(share).to be_valid, "Expected #{platform} to be valid" + end + end + end + + describe 'url' do + it 'requires url to be present' do + share = build(:metrics_share, url: nil) + expect(share).not_to be_valid + expect(share.errors[:url]).to include("can't be blank") + end + + it 'validates url format' do + share = build(:metrics_share, url: 'not-a-url') + expect(share).not_to be_valid + expect(share.errors[:url]).to include('is invalid') + end + + it 'accepts valid HTTP URLs' do + share = build(:metrics_share, url: 'http://example.com/share') + expect(share).to be_valid + end + + it 'accepts valid HTTPS URLs' do + share = build(:metrics_share, url: 'https://example.com/share') + expect(share).to be_valid + end + end + + describe 'shared_at' do + it 'requires shared_at to be present' do + share = build(:metrics_share, shared_at: nil) + expect(share).not_to be_valid + expect(share.errors[:shared_at]).to include("can't be blank") + end + end + + describe 'locale' do + it 'requires locale to be present' do + share = build(:metrics_share, locale: nil) + expect(share).not_to be_valid + expect(share.errors[:locale]).to include("can't be blank") + end + + it 'validates locale is in available locales' do + share = build(:metrics_share, locale: 'invalid') + expect(share).not_to be_valid + expect(share.errors[:locale]).to include('is not included in the list') + end + + it 'accepts valid locales' do + I18n.available_locales.each do |locale| + share = build(:metrics_share, locale: locale.to_s) + expect(share).to be_valid, "Expected #{locale} to be valid" + end + end + end + end + + describe 'constants' do + it 'defines SHAREABLE_PLATFORMS' do + expect(described_class::SHAREABLE_PLATFORMS).to eq(%w[facebook bluesky linkedin pinterest reddit whatsapp]) + end end end end diff --git a/spec/models/better_together/page_spec.rb b/spec/models/better_together/page_spec.rb index 37ccc9c12..2c55689dc 100644 --- a/spec/models/better_together/page_spec.rb +++ b/spec/models/better_together/page_spec.rb @@ -4,7 +4,7 @@ require 'rails_helper' -module BetterTogether +module BetterTogether # rubocop:todo Metrics/ModuleLength RSpec.describe Page do subject(:page) { build(:better_together_page) } @@ -80,6 +80,244 @@ module BetterTogether expect(page.url).to eq("#{::BetterTogether.base_url_with_locale}/#{page.slug}") end end + + describe '#as_indexed_json' do + context 'with template blocks' do + let(:page) do + create(:better_together_page, + title: 'Template Block Page', + slug: 'template-block-page', + privacy: 'public', + page_blocks_attributes: [ + { + block_attributes: { + type: 'BetterTogether::Content::Template', + template_path: 'better_together/static_pages/privacy' + } + } + ]) + end + + it 'includes template_blocks in indexed data' do + result = page.as_indexed_json + + expect(result['template_blocks']).to be_present + expect(result['template_blocks']).to be_an(Array) + end + + it 'includes indexed_localized_content for each template block' do + result = page.as_indexed_json + + template_block = result['template_blocks'].first + expect(template_block['indexed_localized_content']).to be_present + expect(template_block['indexed_localized_content']).to be_a(Hash) + end + + it 'includes content for all locales in template blocks' do + result = page.as_indexed_json + + content = result['template_blocks'].first['indexed_localized_content'] + expect(content.keys.map(&:to_sym)).to match_array(I18n.available_locales) + end + + it 'includes template block id' do + result = page.as_indexed_json + + template_block = result['template_blocks'].first + expect(template_block['id']).to be_present + end + end + + context 'with template attribute' do + let(:page) do + create(:better_together_page, + title: 'Template Attribute Page', + slug: 'template-attribute-page', + privacy: 'public', + template: 'better_together/static_pages/privacy') + end + + it 'includes template_content in indexed data' do + result = page.as_indexed_json + + expect(result['template_content']).to be_present + expect(result['template_content']).to be_a(Hash) + end + + it 'renders template content for all locales' do + result = page.as_indexed_json + + content = result['template_content'] + expect(content.keys.map(&:to_sym)).to match_array(I18n.available_locales) + end + + it 'includes plain text content without HTML' do + result = page.as_indexed_json + + I18n.available_locales.each do |locale| + expect(result['template_content'][locale.to_s]).not_to match(/<[^>]+>/) + end + end + + it 'uses TemplateRendererService for rendering' do + expect(BetterTogether::TemplateRendererService).to receive(:new) + .with(page.template) + .and_call_original + + page.as_indexed_json + end + end + + context 'with rich text blocks' do + let(:page) do + create(:better_together_page, + title: 'Rich Text Page', + slug: 'rich-text-page', + privacy: 'public', + page_blocks_attributes: [ + { + block_attributes: { + type: 'BetterTogether::Content::RichText', + content: 'Test content' + } + } + ]) + end + + it 'includes rich_text_blocks in indexed data' do + result = page.as_indexed_json + + expect(result['rich_text_blocks']).to be_present + expect(result['rich_text_blocks']).to be_an(Array) + end + end + + context 'with markdown blocks' do + let(:page) do + create( + :better_together_page, + title: 'Markdown Index Page', + slug: 'markdown-index-page', + privacy: 'public', + page_blocks_attributes: [ + { + block_attributes: { + type: 'BetterTogether::Content::Markdown', + markdown_source: "# Heading\n\nSearchable paragraph with **formatting**." + } + } + ] + ) + end + + it 'indexes plain text from inline markdown content' do + result = page.as_indexed_json + markdown_block = result['markdown_blocks'].first['as_indexed_json'] + localized_content = markdown_block[:localized_content] || markdown_block['localized_content'] + localized_value = localized_content[I18n.default_locale] || localized_content[I18n.default_locale.to_s] + + expect(localized_value).to include('Heading') + expect(localized_value).to include('Searchable paragraph with formatting.') + expect(localized_value).not_to include('#') + expect(localized_value).not_to include('') + end + end + + context 'with file-based markdown blocks' do + let(:markdown_file_path) { Rails.root.join('spec/fixtures/files/page_markdown_index.md') } + let(:page) do + FileUtils.mkdir_p(markdown_file_path.dirname) + File.write(markdown_file_path, "# File Search\n\nFile body content that should be indexed.") + + create( + :better_together_page, + title: 'Markdown File Index Page', + slug: 'markdown-file-index-page', + privacy: 'public', + page_blocks_attributes: [ + { + block_attributes: { + type: 'BetterTogether::Content::Markdown', + markdown_source: nil, + markdown_file_path: markdown_file_path.to_s + } + } + ] + ) + end + + after do + FileUtils.rm_f(markdown_file_path) + end + + it 'indexes plain text extracted from markdown files' do + result = page.as_indexed_json + markdown_block = result['markdown_blocks'].first['as_indexed_json'] + localized_content = markdown_block[:localized_content] || markdown_block['localized_content'] + localized_value = localized_content[I18n.default_locale] || localized_content[I18n.default_locale.to_s] + + expect(localized_value).to include('File Search') + expect(localized_value).to include('File body content that should be indexed.') + expect(localized_value).not_to include('#') + end + end + + context 'without template blocks or attribute' do + let(:page) do + create(:better_together_page, + title: 'Simple Page', + slug: 'simple-page', + privacy: 'public') + end + + it 'does not include template_content' do + result = page.as_indexed_json + + expect(result['template_content']).to be_nil + end + + it 'includes basic page attributes' do + result = page.as_indexed_json + + expect(result['id']).to eq(page.id) + expect(result['title']).to eq(page.title) + expect(result['slug']).to eq(page.slug) + end + end + + context 'with both template blocks and template attribute' do + let(:page) do + create(:better_together_page, + title: 'Mixed Template Page', + slug: 'mixed-template-page', + privacy: 'public', + template: 'better_together/static_pages/terms_of_service', + page_blocks_attributes: [ + { + block_attributes: { + type: 'BetterTogether::Content::Template', + template_path: 'better_together/static_pages/privacy' + } + } + ]) + end + + it 'includes both template_blocks and template_content' do + result = page.as_indexed_json + + expect(result['template_blocks']).to be_present + expect(result['template_content']).to be_present + end + + it 'renders different content for each' do + result = page.as_indexed_json + + # Both should be present (either as Hash with string keys or symbolized) + expect(result['template_blocks'] || result[:template_blocks]).to be_present + expect(result['template_content'] || result[:template_content]).to be_present + end + end + end end end end diff --git a/spec/models/better_together/phone_number_spec.rb b/spec/models/better_together/phone_number_spec.rb index 1808ff967..9507c53a2 100644 --- a/spec/models/better_together/phone_number_spec.rb +++ b/spec/models/better_together/phone_number_spec.rb @@ -2,10 +2,164 @@ require 'rails_helper' -module BetterTogether - RSpec.describe PhoneNumber do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be +RSpec.describe BetterTogether::PhoneNumber do + describe 'factory' do + it 'creates a valid phone number' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + phone_number = described_class.create!( + contact_detail: contact_detail, + number: '+1-555-123-4567', + label: 'mobile', + primary_flag: true + ) + expect(phone_number).to be_valid + end + end + + describe 'associations' do + it { is_expected.to belong_to(:contact_detail).class_name('BetterTogether::ContactDetail').touch(true) } + end + + describe 'validations' do + describe 'number presence' do + it 'requires number to be present' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + phone_number = described_class.new( + contact_detail: contact_detail, + number: nil, + primary_flag: true + ) + expect(phone_number).not_to be_valid + expect(phone_number.errors[:number]).to include("can't be blank") + end + end + + describe 'number format' do + it 'accepts various phone number formats' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + valid_numbers = [ + '+1-555-123-4567', + '555-123-4567', + '(555) 123-4567', + '555.123.4567', + '5551234567', + '+44 20 7946 0958' + ] + + valid_numbers.each_with_index do |number, index| + phone = described_class.create!( + contact_detail: contact_detail, + number: number, + label: 'mobile', + primary_flag: (index == 0) # Only first one is primary + ) + expect(phone).to be_valid + end + end + end + end + + describe 'PrimaryFlag concern' do + it 'includes PrimaryFlag behavior' do + expect(described_class.included_modules).to include(BetterTogether::PrimaryFlag) + end + + it 'allows setting primary_flag' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + phone_number = described_class.create!( + contact_detail: contact_detail, + number: '+1-555-123-4567', + label: 'mobile', + primary_flag: true + ) + expect(phone_number.primary_flag).to be true + end + + it 'scopes primary flag by contact_detail_id' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + phone1 = described_class.create!( + contact_detail: contact_detail, + number: '+1-555-111-1111', + label: 'mobile', + primary_flag: true + ) + phone2 = described_class.create!( + contact_detail: contact_detail, + number: '+1-555-222-2222', + label: 'home', + primary_flag: false + ) + + expect(phone1.primary_flag).to be true + expect(phone2.primary_flag).to be false + end + end + + describe 'Privacy concern' do + it 'includes Privacy behavior' do + expect(described_class.included_modules).to include(BetterTogether::Privacy) + end + + it 'allows setting privacy level' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + phone_number = described_class.create!( + contact_detail: contact_detail, + number: '+1-555-123-4567', + label: 'mobile', + primary_flag: true, + privacy: 'private' + ) + expect(phone_number.privacy).to eq('private') + end + end + + describe 'Labelable concern' do + it 'includes Labelable behavior' do + expect(described_class.included_modules).to include(BetterTogether::Labelable) + end + + it 'accepts valid labels' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + + BetterTogether::PhoneNumber::LABELS.each_with_index do |label, index| + phone = described_class.create!( + contact_detail: contact_detail, + number: "+1-555-#{100 + index}-0000", + label: label.to_s, + primary_flag: (index == 0) + ) + expect(phone).to be_valid + end + end + + it 'defines expected label constants' do + expect(BetterTogether::PhoneNumber::LABELS).to include(:mobile, :home, :work, :fax, :other) + end + end + + describe 'touch association' do + it 'touches contact_detail on update' do + person = create(:person) + contact_detail = create(:contact_detail, contactable: person) + phone_number = described_class.create!( + contact_detail: contact_detail, + number: '+1-555-123-4567', + label: 'mobile', + primary_flag: true + ) + + original_updated_at = contact_detail.updated_at + sleep 0.01 + phone_number.update!(number: '+1-555-999-9999') + + expect(contact_detail.reload.updated_at).to be > original_updated_at end end end diff --git a/spec/models/better_together/resource_permission_spec.rb b/spec/models/better_together/resource_permission_spec.rb index cec6b8419..718a6658c 100644 --- a/spec/models/better_together/resource_permission_spec.rb +++ b/spec/models/better_together/resource_permission_spec.rb @@ -6,8 +6,106 @@ module BetterTogether RSpec.describe ResourcePermission do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid resource permission' do + permission = build(:resource_permission, resource_type: 'BetterTogether::Community', position: 100) + expect(permission).to be_valid + end + + it 'generates derived target from resource_type' do + permission = create(:resource_permission, resource_type: 'BetterTogether::Community', position: 101) + expected_target = 'community' + expect(permission.target).to eq(expected_target) + end + end + + describe 'associations' do + it { is_expected.to have_many(:role_resource_permissions).class_name('BetterTogether::RoleResourcePermission').dependent(:destroy) } + it { is_expected.to have_many(:roles).through(:role_resource_permissions) } + end + + describe 'validations' do + it { is_expected.to validate_inclusion_of(:action).in_array(described_class::ACTIONS) } + + it 'validates position uniqueness scoped to resource_type' do + create(:resource_permission, resource_type: 'BetterTogether::Community', position: 200) + duplicate = build(:resource_permission, resource_type: 'BetterTogether::Community', position: 200) + + expect(duplicate).not_to be_valid + expect(duplicate.errors[:position]).to be_present + end + + it 'allows same position for different resource_types' do + create(:resource_permission, resource_type: 'BetterTogether::Community', position: 300) + different_type = build(:resource_permission, resource_type: 'BetterTogether::Platform', position: 300) + + expect(different_type).to be_valid + end + end + + describe 'concerns' do + it 'includes Identifier concern' do + expect(described_class.included_modules).to include(BetterTogether::Identifier) + end + + it 'includes Positioned concern' do + expect(described_class.included_modules).to include(BetterTogether::Positioned) + end + + it 'includes Protected concern' do + expect(described_class.included_modules).to include(BetterTogether::Protected) + end + + it 'includes Resourceful concern' do + expect(described_class.included_modules).to include(BetterTogether::Resourceful) + end + end + + describe 'actions constant' do + it 'defines ACTIONS constant' do + expect(described_class::ACTIONS).to eq(%w[create read update delete list manage view]) + end + + it 'accepts valid actions' do + permission = build(:resource_permission, action: 'create', resource_type: 'BetterTogether::Community', position: 400) + expect(permission).to be_valid + end + + it 'rejects invalid actions' do + permission = build(:resource_permission, action: 'invalid_action', resource_type: 'BetterTogether::Community', position: 401) + expect(permission).not_to be_valid + expect(permission.errors[:action]).to be_present + end + end + + describe '#position_scope' do + it 'returns resource_type as position scope' do + permission = build(:resource_permission, resource_type: 'BetterTogether::Community', position: 500) + expect(permission.position_scope).to eq(:resource_type) + end + end + + describe '#to_s' do + it 'returns the identifier' do + permission = create(:resource_permission, resource_type: 'BetterTogether::Community', position: 600) + expect(permission.to_s).to eq(permission.identifier) + end + end + + describe 'scopes' do + describe '.positioned' do + it 'orders by resource_type and position' do + # Use high position numbers to avoid conflicts with seed data + perm1 = create(:resource_permission, resource_type: 'BetterTogether::Platform', position: 1001) + perm2 = create(:resource_permission, resource_type: 'BetterTogether::Community', position: 1001) + perm3 = create(:resource_permission, resource_type: 'BetterTogether::Community', position: 1002) + + positioned = described_class.where('position >= 1001').positioned + + # Should order by resource_type first (alphabetically), then position + expect(positioned.to_a).to eq([perm2, perm3, perm1]) + end + end end end end diff --git a/spec/models/better_together/social_media_account_spec.rb b/spec/models/better_together/social_media_account_spec.rb index 99ecf9c5f..3a441b7b7 100644 --- a/spec/models/better_together/social_media_account_spec.rb +++ b/spec/models/better_together/social_media_account_spec.rb @@ -2,10 +2,169 @@ require 'rails_helper' -module BetterTogether +module BetterTogether # rubocop:disable Metrics/ModuleLength RSpec.describe SocialMediaAccount do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid social media account' do + account = build(:social_media_account) + expect(account).to be_valid + end + + it 'creates valid accounts for different platforms' do + %i[instagram linkedin youtube tiktok reddit].each do |platform_trait| + account = build(:social_media_account, platform_trait) + expect(account).to be_valid + end + end + end + + describe 'associations' do + it { is_expected.to belong_to(:contact_detail).class_name('BetterTogether::ContactDetail').touch(true) } + end + + describe 'validations' do + subject { build(:social_media_account) } + + it { is_expected.to validate_presence_of(:platform) } + it { is_expected.to validate_inclusion_of(:platform).in_array(described_class::PLATFORMS) } + + it 'requires handle if url is not present' do + account = build(:social_media_account, handle: nil, url: nil) + expect(account).not_to be_valid + expect(account.errors[:handle]).to be_present + end + + it 'allows missing handle if url is present' do + account = build(:social_media_account, handle: nil, url: 'https://example.com/profile') + expect(account).to be_valid + end + + it 'validates url format when present' do + account = build(:social_media_account, url: 'not-a-valid-url') + expect(account).not_to be_valid + expect(account.errors[:url]).to be_present + end + + it 'allows valid http url' do + account = build(:social_media_account, url: 'http://example.com/profile') + expect(account).to be_valid + end + + it 'allows valid https url' do + account = build(:social_media_account, url: 'https://example.com/profile') + expect(account).to be_valid + end + + it 'validates uniqueness of platform scoped to contact_detail' do + contact_detail = create(:contact_detail) + create(:social_media_account, contact_detail: contact_detail, platform: 'Facebook') + duplicate = build(:social_media_account, contact_detail: contact_detail, platform: 'Facebook') + + expect(duplicate).not_to be_valid + expect(duplicate.errors[:platform]).to include('account already exists for this contact detail') + end + + it 'allows same platform for different contact_details' do + contact1 = create(:contact_detail) + contact2 = create(:contact_detail) + create(:social_media_account, contact_detail: contact1, platform: 'Facebook') + account2 = build(:social_media_account, contact_detail: contact2, platform: 'Facebook') + + expect(account2).to be_valid + end + end + + describe 'url generation' do + it 'generates url from handle for Facebook' do + account = create(:social_media_account, platform: 'Facebook', handle: 'johndoe', url: nil) + expect(account.url).to eq('https://www.facebook.com/johndoe') + end + + it 'generates url from handle for Instagram' do + account = create(:social_media_account, platform: 'Instagram', handle: 'johndoe', url: nil) + expect(account.url).to eq('https://www.instagram.com/johndoe') + end + + it 'generates url from handle for LinkedIn' do + account = create(:social_media_account, platform: 'LinkedIn', handle: 'johndoe', url: nil) + expect(account.url).to eq('https://www.linkedin.com/in/johndoe') + end + + it 'generates url from handle for YouTube' do + account = create(:social_media_account, platform: 'YouTube', handle: 'johndoe', url: nil) + expect(account.url).to eq('https://www.youtube.com/johndoe') + end + + it 'generates url from handle for TikTok' do + account = create(:social_media_account, platform: 'TikTok', handle: 'johndoe', url: nil) + expect(account.url).to eq('https://www.tiktok.com/@johndoe') + end + + it 'generates url from handle for Reddit' do + account = create(:social_media_account, platform: 'Reddit', handle: 'johndoe', url: nil) + expect(account.url).to eq('https://www.reddit.com/user/johndoe') + end + + it 'does not override existing url' do + existing_url = 'https://custom.url/profile' + account = create(:social_media_account, platform: 'Facebook', handle: 'johndoe', url: existing_url) + expect(account.url).to eq(existing_url) + end + + it 'regenerates url when handle changes and url is blank' do + account = create(:social_media_account, platform: 'Facebook', handle: 'johndoe', url: nil) + original_url = account.url + + account.update(handle: 'janedoe', url: nil) + expect(account.url).to eq('https://www.facebook.com/janedoe') + expect(account.url).not_to eq(original_url) + end + + it 'regenerates url when platform changes with handle present and url blank' do + account = create(:social_media_account, platform: 'Facebook', handle: 'johndoe', url: nil) + account.update(platform: 'Instagram', url: nil) + expect(account.url).to eq('https://www.instagram.com/johndoe') + end + end + + describe 'handle sanitization' do + it 'removes leading @ from handle' do + account = create(:social_media_account, platform: 'Instagram', handle: '@johndoe', url: nil) + expect(account.url).to eq('https://www.instagram.com/johndoe') + end + + it 'parameterizes handle' do + account = create(:social_media_account, platform: 'Facebook', handle: 'John Doe', url: nil) + expect(account.url).to eq('https://www.facebook.com/john-doe') + end + + it 'strips whitespace from handle' do + account = create(:social_media_account, platform: 'Facebook', handle: ' johndoe ', url: nil) + expect(account.url).to eq('https://www.facebook.com/johndoe') + end + end + + describe '#to_s' do + it 'returns platform and handle' do + account = build(:social_media_account, platform: 'Facebook', handle: 'johndoe') + expect(account.to_s).to eq('Facebook: johndoe') + end + end + + describe 'privacy concern' do + it 'includes Privacy concern' do + expect(described_class.included_modules).to include(BetterTogether::Privacy) + end + + it 'has default privacy level' do + account = create(:social_media_account) + expect(account.privacy).to eq('public') + end + + it 'can be set to private' do + account = create(:social_media_account, :private) + expect(account.privacy).to eq('private') + end end end end diff --git a/spec/models/better_together/website_link_spec.rb b/spec/models/better_together/website_link_spec.rb index 4ba159aa6..7e2693c6f 100644 --- a/spec/models/better_together/website_link_spec.rb +++ b/spec/models/better_together/website_link_spec.rb @@ -4,8 +4,108 @@ module BetterTogether RSpec.describe WebsiteLink do - it 'exists' do - expect(described_class).to be # rubocop:todo RSpec/Be + describe 'factory' do + it 'creates a valid website link' do + link = build(:website_link) + expect(link).to be_valid + end + + it 'creates valid links with different labels' do + %i[blog portfolio company_website community_page documentation].each do |label_trait| + link = build(:website_link, label_trait) + expect(link).to be_valid + end + end + end + + describe 'associations' do + it { is_expected.to belong_to(:contact_detail).class_name('BetterTogether::ContactDetail').touch(true) } + end + + describe 'validations' do + it { is_expected.to validate_presence_of(:url) } + + it 'validates url format with http' do + link = build(:website_link, url: 'http://example.com') + expect(link).to be_valid + end + + it 'validates url format with https' do + link = build(:website_link, url: 'https://example.com') + expect(link).to be_valid + end + + it 'rejects invalid url format' do + link = build(:website_link, url: 'not-a-valid-url') + expect(link).not_to be_valid + expect(link.errors[:url]).to be_present + end + + it 'rejects url without protocol' do + link = build(:website_link, url: 'example.com') + expect(link).not_to be_valid + expect(link.errors[:url]).to be_present + end + + it 'rejects ftp protocol' do + link = build(:website_link, url: 'ftp://example.com') + expect(link).not_to be_valid + expect(link.errors[:url]).to be_present + end + end + + describe 'labelable concern' do + it 'includes Labelable concern' do + expect(described_class.included_modules).to include(BetterTogether::Labelable) + end + + it 'defines LABELS constant' do + expect(described_class::LABELS).to be_a(Array) + expect(described_class::LABELS).not_to be_empty + end + + it 'includes expected label types' do + expected_labels = %i[ + personal_website blog portfolio resume company_website community_page + product_page services support contact_us about_us events donations careers + privacy_policy terms_of_service faq forum documentation newsletter other + ] + expect(described_class::LABELS).to eq(expected_labels) + end + + it 'can be created with different label values' do + %i[blog portfolio company_website documentation].each do |label_value| + link = create(:website_link, label: label_value.to_s) + expect(link.label).to eq(label_value.to_s) + end + end + end + + describe 'privacy concern' do + it 'includes Privacy concern' do + expect(described_class.included_modules).to include(BetterTogether::Privacy) + end + + it 'has default privacy level' do + link = create(:website_link) + expect(link.privacy).to eq('public') + end + + it 'can be set to private' do + link = create(:website_link, :private) + expect(link.privacy).to eq('private') + end + end + + describe 'touch behavior' do + it 'touches contact_detail when updated' do + link = create(:website_link) + contact_detail = link.contact_detail + + expect do + link.update(url: 'https://newurl.com') + end.to(change { contact_detail.reload.updated_at }) + end end end end diff --git a/spec/policies/better_together/content/markdown_policy_spec.rb b/spec/policies/better_together/content/markdown_policy_spec.rb new file mode 100644 index 000000000..02d0eab92 --- /dev/null +++ b/spec/policies/better_together/content/markdown_policy_spec.rb @@ -0,0 +1,174 @@ +# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe BetterTogether::Content::MarkdownPolicy, type: :policy do + let(:manager_user) { create(:better_together_user, :platform_manager) } + let(:normal_user) { create(:better_together_user) } + let(:markdown_block) { create(:content_markdown) } + + describe '#index?' do + subject { described_class.new(user, markdown_block).index? } + + context 'when user is a platform manager' do + let(:user) { manager_user } + + it { is_expected.to be true } + end + + context 'when user is a normal user' do + let(:user) { normal_user } + + it { is_expected.to be false } + end + + context 'when user is not signed in' do + let(:user) { nil } + + it { is_expected.to be false } + end + end + + describe '#show?' do + subject { described_class.new(user, markdown_block).show? } + + context 'when user is a platform manager' do + let(:user) { manager_user } + + it { is_expected.to be true } + end + + context 'when user is a normal user' do + let(:user) { normal_user } + + it { is_expected.to be false } + end + + context 'when user is not signed in' do + let(:user) { nil } + + it { is_expected.to be false } + end + end + + describe '#create?' do + subject { described_class.new(user, markdown_block).create? } + + context 'when user is a platform manager' do + let(:user) { manager_user } + + it { is_expected.to be true } + end + + context 'when user is a normal user' do + let(:user) { normal_user } + + it { is_expected.to be false } + end + + context 'when user is not signed in' do + let(:user) { nil } + + it { is_expected.to be false } + end + end + + describe '#new?' do + subject { described_class.new(user, markdown_block).new? } + + context 'when user is a platform manager' do + let(:user) { manager_user } + + it { is_expected.to be true } + end + + context 'when user is a normal user' do + let(:user) { normal_user } + + it { is_expected.to be false } + end + end + + describe '#update?' do + subject { described_class.new(user, markdown_block).update? } + + context 'when user is a platform manager' do + let(:user) { manager_user } + + it { is_expected.to be true } + end + + context 'when user is a normal user' do + let(:user) { normal_user } + + it { is_expected.to be false } + end + + context 'when user is not signed in' do + let(:user) { nil } + + it { is_expected.to be false } + end + end + + describe '#edit?' do + subject { described_class.new(user, markdown_block).edit? } + + context 'when user is a platform manager' do + let(:user) { manager_user } + + it { is_expected.to be true } + end + + context 'when user is a normal user' do + let(:user) { normal_user } + + it { is_expected.to be false } + end + end + + describe '#destroy?' do + subject { described_class.new(user, markdown_block).destroy? } + + context 'when user is a platform manager' do + let(:user) { manager_user } + + it { is_expected.to be true } + end + + context 'when user is a normal user' do + let(:user) { normal_user } + + it { is_expected.to be false } + end + + context 'when user is not signed in' do + let(:user) { nil } + + it { is_expected.to be false } + end + end + + describe 'Scope' do + let!(:markdown_block1) { create(:content_markdown) } # rubocop:todo RSpec/IndexedLet + let!(:markdown_block2) { create(:content_markdown) } # rubocop:todo RSpec/IndexedLet + + context 'when user is a platform manager' do + let(:user) { manager_user } + + it 'returns all markdown blocks' do + scope = described_class::Scope.new(user, BetterTogether::Content::Markdown.all).resolve + expect(scope).to include(markdown_block1, markdown_block2) + end + end + + context 'when user is a normal user' do + let(:user) { normal_user } + + it 'returns all markdown blocks (filtering happens in policy methods)' do + scope = described_class::Scope.new(user, BetterTogether::Content::Markdown.all).resolve + expect(scope).to include(markdown_block1, markdown_block2) + end + end + end +end diff --git a/spec/requests/better_together/content_blocks_preview_markdown_spec.rb b/spec/requests/better_together/content_blocks_preview_markdown_spec.rb new file mode 100644 index 000000000..d47c4b263 --- /dev/null +++ b/spec/requests/better_together/content_blocks_preview_markdown_spec.rb @@ -0,0 +1,198 @@ +# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe 'Content Blocks Markdown Preview', :as_user do + let(:markdown_content) { "# Hello World\n\nThis is a **test**." } + let(:preview_path) { "/#{I18n.default_locale}/#{BetterTogether.route_scope_path}/content/blocks/preview_markdown" } + + describe 'POST /better_together/content/blocks/preview_markdown' do + context 'when markdown content is provided' do + it 'returns rendered HTML' do + post preview_path, + params: { markdown: markdown_content }, + as: :json + + expect(response).to have_http_status(:ok) + expect(response.content_type).to match(%r{application/json}) + + json_response = JSON.parse(response.body) + expect(json_response['html']).to include('Hello World
') + expect(json_response['html']).to include('test') + end + + it 'renders markdown with code blocks' do + markdown_with_code = <<~MARKDOWN + # Code Example + + ```ruby + def hello + puts "Hello, World!" + end + ``` + MARKDOWN + + post preview_path, + params: { markdown: markdown_with_code }, + as: :json + + expect(response).to have_http_status(:ok) + json_response = JSON.parse(response.body) + expect(json_response['html']).to include('- ')
+ expect(json_response['html']).to include('
- ')
+ end
+
+ it 'renders blockquotes' do
+ markdown = '> This is a quote'
+
+ post preview_path,
+ params: { markdown: markdown },
+ as: :json
+
+ expect(response).to have_http_status(:ok)
+ json_response = JSON.parse(response.body)
+ expect(json_response['html']).to include('
') + end + + it 'renders inline code' do + markdown = 'Use `code` in text' + + post preview_path, + params: { markdown: markdown }, + as: :json + + expect(response).to have_http_status(:ok) + json_response = JSON.parse(response.body) + expect(json_response['html']).to include('
code') + end + end + end +end diff --git a/spec/requests/better_together/metrics/reports_controller_spec.rb b/spec/requests/better_together/metrics/reports_controller_spec.rb new file mode 100644 index 000000000..8fa0ffa6b --- /dev/null +++ b/spec/requests/better_together/metrics/reports_controller_spec.rb @@ -0,0 +1,211 @@ +# frozen_string_literal: true + +require 'rails_helper' + +# rubocop:disable RSpec/IndexedLet +module BetterTogether + module Metrics # rubocop:disable Metrics/ModuleLength + RSpec.describe ReportsController do + describe 'GET #index', :as_platform_manager do + let!(:page_view1) do + create(:metrics_page_view, + page_url: '/page1', + viewed_at: 2.days.ago) + end + let!(:page_view2) do + create(:metrics_page_view, + page_url: '/page1', + viewed_at: 1.day.ago) + end + let!(:page_view3) do + create(:metrics_page_view, + page_url: '/page2', + viewed_at: 1.day.ago) + end + + let!(:link_click1) do + create(:metrics_link_click, + url: 'https://example.com', + page_url: '/page1', + internal: false, + clicked_at: 2.days.ago) + end + let!(:link_click2) do + create(:metrics_link_click, + url: 'https://internal.example.com/path', + page_url: '/page2', + internal: true, + clicked_at: 1.day.ago) + end + + let!(:download) do + create(:metrics_download, + file_name: 'document.pdf') + end + + let!(:share1) do + create(:metrics_share, + url: 'https://facebook.com/share/page1', + platform: 'facebook') + end + let!(:share2) do + create(:metrics_share, + url: 'https://bsky.app/share/page1', + platform: 'bluesky') + end + let!(:share3) do + create(:metrics_share, + url: 'https://facebook.com/share/page2', + platform: 'facebook') + end + + let!(:valid_link) do + create(:content_link, + host: 'example.com', + valid_link: true, + last_checked_at: 1.day.ago) + end + let!(:invalid_link) do + create(:content_link, + host: 'broken.com', + valid_link: false, + last_checked_at: 1.day.ago) + end + + before do + get better_together.metrics_reports_path(locale: I18n.default_locale) + end + + it 'returns http success' do + expect(response).to have_http_status(:success) + end + + it 'assigns page views grouped by URL' do + expect(assigns(:page_views_by_url)).to be_present + expect(assigns(:page_views_by_url)['/page1']).to eq(2) + expect(assigns(:page_views_by_url)['/page2']).to eq(1) + end + + it 'assigns page views grouped by day' do + expect(assigns(:page_views_daily)).to be_present + expect(assigns(:page_views_daily)).to be_a(Hash) + end + + it 'assigns link clicks grouped by URL' do + expect(assigns(:link_clicks_by_url)).to be_present + expect(assigns(:link_clicks_by_url)['https://example.com']).to eq(1) + expect(assigns(:link_clicks_by_url)['https://internal.example.com/path']).to eq(1) + end + + it 'assigns link clicks grouped by day' do + expect(assigns(:link_clicks_daily)).to be_present + expect(assigns(:link_clicks_daily)).to be_a(Hash) + end + + it 'assigns internal vs external link clicks' do + expect(assigns(:internal_vs_external)).to be_present + expect(assigns(:internal_vs_external)[true]).to eq(1) # internal + expect(assigns(:internal_vs_external)[false]).to eq(1) # external + end + + it 'assigns link clicks grouped by page' do + expect(assigns(:link_clicks_by_page)).to be_present + expect(assigns(:link_clicks_by_page)['/page1']).to eq(1) + expect(assigns(:link_clicks_by_page)['/page2']).to eq(1) + end + + it 'assigns downloads grouped by file' do + expect(assigns(:downloads_by_file)).to be_present + expect(assigns(:downloads_by_file)['document.pdf']).to eq(1) + end + + it 'assigns shares grouped by platform' do + expect(assigns(:shares_by_platform)).to be_present + expect(assigns(:shares_by_platform)['facebook']).to eq(2) + expect(assigns(:shares_by_platform)['bluesky']).to eq(1) + end + + it 'assigns shares grouped by URL and platform' do + expect(assigns(:shares_by_url_and_platform)).to be_present + expect(assigns(:shares_by_url_and_platform)[['https://facebook.com/share/page1', 'facebook']]).to eq(1) + expect(assigns(:shares_by_url_and_platform)[['https://bsky.app/share/page1', 'bluesky']]).to eq(1) + expect(assigns(:shares_by_url_and_platform)[['https://facebook.com/share/page2', 'facebook']]).to eq(1) + end + + it 'assigns shares data for Chart.js' do + expect(assigns(:shares_data)).to be_present + expect(assigns(:shares_data)[:labels]).to include('https://facebook.com/share/page1', 'https://facebook.com/share/page2') + expect(assigns(:shares_data)[:datasets]).to be_an(Array) + expect(assigns(:shares_data)[:datasets].map { |d| d[:label] }).to include('Facebook', 'Bluesky') + end + + it 'assigns links grouped by host' do + expect(assigns(:links_by_host)).to be_present + expect(assigns(:links_by_host)['example.com']).to eq(1) + expect(assigns(:links_by_host)['broken.com']).to eq(1) + end + + it 'assigns invalid links grouped by host' do + expect(assigns(:invalid_by_host)).to be_present + expect(assigns(:invalid_by_host)['broken.com']).to eq(1) + expect(assigns(:invalid_by_host)['example.com']).to be_nil + end + + it 'assigns failures grouped by day' do + expect(assigns(:failures_daily)).to be_present + expect(assigns(:failures_daily)).to be_a(Hash) + end + + context 'when testing Chart.js data structure' do + it 'generates proper dataset structure' do + datasets = assigns(:shares_data)[:datasets] + expect(datasets.first).to have_key(:label) + expect(datasets.first).to have_key(:backgroundColor) + expect(datasets.first).to have_key(:data) + end + + it 'includes color for each platform' do + datasets = assigns(:shares_data)[:datasets] + datasets.each do |dataset| + expect(dataset[:backgroundColor]).to be_present + expect(dataset[:backgroundColor]).to match(/rgba\(\d+,\s*\d+,\s*\d+,\s*[\d.]+\)/) + end + end + end + end + + describe '#random_color_for_platform' do + let(:controller) { described_class.new } + + it 'returns specific color for facebook' do + expect(controller.random_color_for_platform('facebook')).to eq('rgba(59, 89, 152, 0.5)') + end + + it 'returns specific color for bluesky' do + expect(controller.random_color_for_platform('bluesky')).to eq('rgba(29, 161, 242, 0.5)') + end + + it 'returns specific color for linkedin' do + expect(controller.random_color_for_platform('linkedin')).to eq('rgba(0, 123, 182, 0.5)') + end + + it 'returns specific color for pinterest' do + expect(controller.random_color_for_platform('pinterest')).to eq('rgba(189, 8, 28, 0.5)') + end + + it 'returns specific color for reddit' do + expect(controller.random_color_for_platform('reddit')).to eq('rgba(255, 69, 0, 0.5)') + end + + it 'returns specific color for whatsapp' do + expect(controller.random_color_for_platform('whatsapp')).to eq('rgba(37, 211, 102, 0.5)') + end + + it 'returns default color for unknown platform' do + expect(controller.random_color_for_platform('unknown')).to eq('rgba(75, 192, 192, 0.5)') + end + end + end + end +end +# rubocop:enable RSpec/IndexedLet diff --git a/spec/requests/better_together/pages_filtering_spec.rb b/spec/requests/better_together/pages_filtering_spec.rb index 1be502f1e..b24eb9301 100644 --- a/spec/requests/better_together/pages_filtering_spec.rb +++ b/spec/requests/better_together/pages_filtering_spec.rb @@ -3,9 +3,10 @@ require 'rails_helper' RSpec.describe 'Pages filtering and sorting', :as_platform_manager do - let(:alpha) { create(:better_together_page, title: 'Alpha Page', slug: 'alpha-page') } - let(:beta) { create(:better_together_page, title: 'Beta Page', slug: 'beta-page') } - let(:gamma) { create(:better_together_page, title: 'Gamma Page', slug: 'gamma-page') } + # Use identifier prefixes that sort early alphabetically to ensure pages appear on first page + let(:alpha) { create(:better_together_page, title: 'Alpha Page', slug: 'aaa-alpha-page', identifier: 'aaa-alpha-page', protected: false) } + let(:beta) { create(:better_together_page, title: 'Beta Page', slug: 'aaa-beta-page', identifier: 'aaa-beta-page', protected: false) } + let(:gamma) { create(:better_together_page, title: 'Gamma Page', slug: 'aaa-gamma-page', identifier: 'aaa-gamma-page', protected: false) } before do alpha diff --git a/spec/requests/better_together/pages_markdown_rendering_spec.rb b/spec/requests/better_together/pages_markdown_rendering_spec.rb new file mode 100644 index 000000000..4866ddfae --- /dev/null +++ b/spec/requests/better_together/pages_markdown_rendering_spec.rb @@ -0,0 +1,56 @@ +# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe 'Markdown pages' do + let(:page) do + create( + :better_together_page, + title: 'Markdown Page', + slug: 'markdown-page', + privacy: 'public', + published_at: Time.zone.now + ) + end + + let(:page_path) { "/#{I18n.default_locale}/#{page.slug}" } + + describe 'GET /:locale/:path' do + let(:markdown_content) { "# Markdown Heading\n\nThis is **bold** content for the page." } + let(:markdown_block) { create(:content_markdown, markdown_source: markdown_content) } + let!(:page_block) { BetterTogether::Content::PageBlock.create!(page:, block: markdown_block, position: 0) } + + it 'renders markdown blocks as HTML on the page' do + get page_path + + expect(response).to have_http_status(:ok) + expect(response.body).to include('
Page Without Hero
') + end + + it 'includes the page title in a container div' do + get better_together.page_path(page_without_hero.slug, locale: I18n.default_locale) + + expect(response).to have_http_status(:success) + expect(response.body).to include('') + expect(response.body).to match(%r{+ HTML + end + + it 'only adds icons to external links' do + result = sanitizer.sanitize(mixed_html) + + # Only one external link should have icon + expect(result.scan('fa-external-link-alt').count).to eq(1) + end + + it 'preserves internal links unchanged' do + result = sanitizer.sanitize(mixed_html) + + expect(result).to include('Internal') + end + end + + context 'with malformed URLs' do + it 'handles invalid URLs gracefully' do + html = 'Invalid' + result = sanitizer.sanitize(html) + + # Should not crash, URL parsing fails gracefully + expect(result).to be_a(String) + end + + it 'handles URLs without host' do + html = 'JS Link' + result = sanitizer.sanitize(html) + + # javascript: URLs have no host, should not crash + expect(result).to be_a(String) + end + + it 'handles empty href' do + html = 'Empty' + result = sanitizer.sanitize(html) + + expect(result).to be_a(String) + end + end + + context 'with different protocols' do + it 'handles HTTPS links' do + html = 'Secure' + result = sanitizer.sanitize(html) + + expect(result).to include('fa-external-link-alt') + end + + it 'handles HTTP links' do + html = 'Insecure' + result = sanitizer.sanitize(html) + + expect(result).to include('fa-external-link-alt') + end + + it 'handles FTP links' do + html = 'FTP' + result = sanitizer.sanitize(html) + + expect(result).to include('fa-external-link-alt') + end + + it 'handles mailto links' do + html = 'Email' + result = sanitizer.sanitize(html) + + # mailto has no host, should not add external icon + expect(result).not_to include('fa-external-link-alt') + end + + it 'handles tel links' do + html = 'Phone' + result = sanitizer.sanitize(html) + + # tel has no host, should not add external icon + expect(result).not_to include('fa-external-link-alt') + end + end + + context 'with complex HTML structures' do + it 'handles nested elements in links' do + html = 'Link' + result = sanitizer.sanitize(html) + + expect(result).to include('fa-external-link-alt') + end + + it 'handles links with images' do + html = '.*}m) + end + end + + context 'when page has a hero block' do + let(:page_with_hero) do + create(:better_together_page, + title: 'Page With Hero', + slug: 'aaa-page-with-hero', + identifier: 'aaa-page-with-hero', + protected: false, + published_at: 1.day.ago) + end + + before do + # Add a hero block to the page + hero_block = create(:content_hero, + title: 'Hero Title', + subtitle: 'Hero Subtitle') + page_with_hero.page_blocks.create!(block: hero_block, position: 0) + end + + it 'does not display the page title as an h1' do + get better_together.page_path(page_with_hero.slug, locale: I18n.default_locale) + + expect(response).to have_http_status(:success) + expect(response.body).not_to include('Page Without Hero
.*Page With Hero
') + end + + it 'renders the hero block instead' do + get better_together.page_path(page_with_hero.slug, locale: I18n.default_locale) + + expect(response).to have_http_status(:success) + # Hero blocks have their own title rendering + expect(response.body).to include('Hero Title') + expect(response.body).to include('Hero Subtitle') + end + end + + context 'when page has template and no content blocks' do + let(:page_with_template) do + create(:better_together_page, + title: 'Page With Template', + slug: 'aaa-page-with-template', + identifier: 'aaa-page-with-template', + protected: false, + published_at: 1.day.ago, + template: 'better_together/static_pages/better_together') + end + + it 'does not display the page title as an h1' do + get better_together.page_path(page_with_template.slug, locale: I18n.default_locale) + + expect(response).to have_http_status(:success) + # Template pages handle their own title rendering + expect(response.body).not_to include('Page With Template
') + end + end + + context 'when page has multiple blocks but no hero' do + let(:page_with_multiple_blocks) do + create(:better_together_page, + title: 'Multi Block Page', + slug: 'aaa-multi-block-page', + identifier: 'aaa-multi-block-page', + protected: false, + published_at: 1.day.ago) + end + + before do + # Add multiple non-hero blocks + markdown_block1 = create(:content_markdown, markdown_source: '## First section') + markdown_block2 = create(:content_markdown, markdown_source: '## Second section') + page_with_multiple_blocks.page_blocks.create!(block: markdown_block1, position: 0) + page_with_multiple_blocks.page_blocks.create!(block: markdown_block2, position: 1) + end + + it 'displays the page title as an h1 before the content' do + get better_together.page_path(page_with_multiple_blocks.slug, locale: I18n.default_locale) + + expect(response).to have_http_status(:success) + expect(response.body).to include('Multi Block Page
') + + # Verify title appears before content + title_position = response.body.index('Multi Block Page
') + content_position = response.body.index('First section') + expect(title_position).to be < content_position + end + end + + context 'when page title contains HTML-sensitive characters' do + let(:page_with_special_chars) do + create(:better_together_page, + title: 'Page & Title"Special" Characters', + slug: 'aaa-page-special-chars', + identifier: 'aaa-page-special-chars', + protected: false, + published_at: 1.day.ago) + end + + before do + markdown_block = create(:content_markdown, markdown_source: '## Test content') + page_with_special_chars.page_blocks.create!(block: markdown_block, position: 0) + end + + it 'properly escapes the title' do + get better_together.page_path(page_with_special_chars.slug, locale: I18n.default_locale) + + expect(response).to have_http_status(:success) + expect(response.body).to include('Page & Title <with> "Special" Characters') + expect(response.body).not_to include('Page & Title "Special" Characters') + end + end + end +end diff --git a/spec/requests/better_together/setup_wizard_steps_controller_spec.rb b/spec/requests/better_together/setup_wizard_steps_controller_spec.rb new file mode 100644 index 000000000..12cc23eb2 --- /dev/null +++ b/spec/requests/better_together/setup_wizard_steps_controller_spec.rb @@ -0,0 +1,398 @@ +# frozen_string_literal: true + +require 'rails_helper' + +# rubocop:disable Metrics/ModuleLength +module BetterTogether + RSpec.describe SetupWizardStepsController, :skip_host_setup do + let(:wizard) { Wizard.find_or_create_by!(identifier: 'host_setup') } + let(:platform_details_step) do + WizardStepDefinition.find_or_create_by!( + wizard:, + identifier: 'platform_details' + ) do |step| + step.step_number = 1 + step.template = 'better_together/setup_wizard_steps/platform_details' + end + end + let(:admin_creation_step) do + WizardStepDefinition.find_or_create_by!( + wizard:, + identifier: 'admin_creation' + ) do |step| + step.step_number = 2 + step.template = 'better_together/setup_wizard_steps/admin_creation' + end + end + + before do + # Ensure wizard exists and steps are loaded + platform_details_step + admin_creation_step + + # Reset wizard completion status for fresh testing + wizard.update!( + current_completions: 0, + first_completed_at: nil, + last_completed_at: nil + ) + wizard.wizard_steps.destroy_all + end + + describe 'GET #platform_details' do + before do + get better_together.setup_wizard_step_platform_details_path(locale: I18n.default_locale) + end + + it 'returns http success' do + expect(response).to have_http_status(:success) + end + + it 'renders the platform details form' do + expect(response.body).to include('name') + expect(response.body).to include('description') + expect(response.body).to include('url') + end + end + + describe 'POST #create_host_platform' do + let(:valid_platform_params) do + { + name: 'Test Platform', + description: 'Test Description', + url: 'http://test.example.com', + time_zone: 'UTC', + privacy: 'private' + } + end + + context 'with valid parameters' do + before do + post better_together.setup_wizard_step_create_host_platform_path(locale: I18n.default_locale), + params: { platform: valid_platform_params } + end + + it 'creates a new platform' do + expect(Platform.count).to eq(1) + end + + it 'sets the platform as host' do + platform = Platform.last + expect(platform.host).to be true + end + + it 'marks the wizard step as completed' do + wizard.reload + step = wizard.wizard_steps.find_by(wizard_step_definition: platform_details_step) + expect(step&.completed).to be true + end + + it 'redirects to the next step' do + expect(response).to have_http_status(:redirect) + end + end + + context 'with invalid parameters' do + let(:invalid_platform_params) do + { + name: '', + description: '', + url: '', + time_zone: 'UTC', + privacy: 'private' + } + end + + before do + post better_together.setup_wizard_step_create_host_platform_path(locale: I18n.default_locale), + params: { platform: invalid_platform_params } + end + + it 'does not create a platform' do + expect(Platform.count).to eq(0) + end + + it 'renders the platform_details template' do + expect(response).to have_http_status(:unprocessable_content) + end + + it 'displays validation errors' do + expect(response.body).to match(/error|invalid/i) + end + + it 'sets flash alert' do + expect(flash[:alert]).to be_present + end + end + + context 'when ActiveRecord::RecordInvalid is raised' do + before do + # Create a platform with a validation error + invalid_platform = Platform.new + invalid_platform.errors.add(:base, 'Test validation error') + + # rubocop:disable RSpec/AnyInstance + allow_any_instance_of(Platform).to receive(:save!).and_raise( + ActiveRecord::RecordInvalid.new(invalid_platform) + ) + # rubocop:enable RSpec/AnyInstance + + post better_together.setup_wizard_step_create_host_platform_path(locale: I18n.default_locale), + params: { platform: valid_platform_params } + end + + it 'handles the exception' do + expect(response).to have_http_status(:unprocessable_content) + end + + it 'shows error message in response' do + # flash.now is used in controller, which renders error in the response body + # Check that error-related content is displayed + expect(response.body).to match(/error|invalid|please/i) + end + end + end + + describe 'GET #admin_creation' do + it 'redirects to appropriate step based on wizard state' do + skip 'Complex wizard state management - covered by integration tests' + end + end + + describe 'POST #create_admin' do + # The wizard creates the FIRST user - no pre-existing users should exist + # The host platform and community are created in the previous wizard step (create_host_platform) + # Use find_or_create_by to handle seed data + before do + ::BetterTogether::Platform.find_or_create_by(host: true) do |platform| + platform.name = 'Test Platform' + platform.url = 'http://test.example.com' + platform.privacy = 'public' + platform.identifier = 'test-platform' + platform.time_zone = 'UTC' + end + + ::BetterTogether::Community.find_or_create_by(host: true) do |community| + community.name = 'Test Community' + community.identifier = 'test-community' + end + + # Ensure no users exist before the wizard creates the first one + ::BetterTogether::User.destroy_all + end + + # Roles must exist for memberships to be created + let!(:platform_manager_role) do + ::BetterTogether::Role.find_or_create_by(identifier: 'platform_manager') do |role| + role.name = 'Platform Manager' + role.resource_type = 'BetterTogether::Platform' + end + end + let!(:governance_role) do + ::BetterTogether::Role.find_or_create_by(identifier: 'community_governance_council') do |role| + role.name = 'Community Governance Council' + role.resource_type = 'BetterTogether::Community' + end + end + + let(:valid_user_params) do + { + email: 'admin@example.com', + password: '!StrongPass12345?', + password_confirmation: '!StrongPass12345?', + person_attributes: { + identifier: 'admin-user', + name: 'Admin User', + description: 'Platform Administrator' + } + } + end + + # No need to stub helpers since host_platform/host_community exist in DB + + context 'with valid parameters' do + before do + # Wizard should start with ZERO users and create the first one + raise "Expected 0 users before wizard creates first admin, found #{User.count}" unless User.none? + + post better_together.setup_wizard_step_create_admin_path(locale: I18n.default_locale), + params: { user: valid_user_params } + end + + it 'creates a new user' do + expect(User.count).to eq(1) + end + + it 'creates associated person' do + user = User.find_by(email: 'admin@example.com') + expect(user).to be_present + expect(user.person).to be_present + expect(user.person.name).to eq('Admin User') + end + + it 'creates platform membership with platform_manager role' do + user = User.find_by(email: 'admin@example.com') + host_platform = ::BetterTogether::Platform.find_by(host: true) + membership = host_platform.person_platform_memberships.find_by(member: user.person) + expect(membership).to be_present + expect(membership.role).to eq(platform_manager_role) + end + + it 'creates community membership with governance role' do + user = User.find_by(email: 'admin@example.com') + host_community = ::BetterTogether::Community.find_by(host: true) + membership = host_community.person_community_memberships.find_by(member: user.person) + expect(membership).to be_present + expect(membership.role).to eq(governance_role) + end + + it 'sets user as community creator' do + user = User.find_by(email: 'admin@example.com') + host_community = ::BetterTogether::Community.find_by(host: true) + host_community.reload + expect(host_community.creator).to eq(user.person) + end + + it 'marks the wizard step as completed' do + wizard.reload + + # Find the step that should be completed + step = wizard.wizard_steps.find_by(identifier: 'admin_creation') + + # The step should exist and be marked as completed + expect(step).to be_present + expect(step.completed).to be(true) + end + + it 'redirects to appropriate location' do + expect(response).to have_http_status(:redirect) + end + end + + context 'with invalid parameters' do + let(:invalid_user_params) do + { + email: 'invalid-email', + password: 'short', + password_confirmation: 'different', + person: { + identifier: '', + name: '', + description: '' + } + } + end + + before do + post better_together.setup_wizard_step_create_admin_path(locale: I18n.default_locale), + params: { user: invalid_user_params } + end + + it 'does not create a user' do + expect(User.count).to eq(0) + end + + it 'renders the admin_creation template' do + expect(response).to have_http_status(:unprocessable_content) + end + + it 'displays validation errors in response' do + expect(response.body).to match(/error|invalid/i) + end + + it 'sets flash alert' do + expect(flash[:alert]).to be_present + end + end + + context 'when ActiveRecord::RecordInvalid is raised' do + before do + # Create a user with a validation error + invalid_user = User.new + invalid_user.errors.add(:base, 'Test validation error') + + # rubocop:disable RSpec/AnyInstance + allow_any_instance_of(User).to receive(:save!).and_raise( + ActiveRecord::RecordInvalid.new(invalid_user) + ) + # rubocop:enable RSpec/AnyInstance + + post better_together.setup_wizard_step_create_admin_path(locale: I18n.default_locale), + params: { user: valid_user_params } + end + + it 'handles the exception' do + expect(response).to have_http_status(:unprocessable_content) + end + + it 'shows error message in response' do + # flash.now is used in controller, which renders error in the response body + # Check that error-related content is displayed + expect(response.body).to match(/error|invalid|please/i) + end + + it 'renders the form again' do + expect(response.body).to match(/email|password/i) + end + end + end + + describe 'GET #redirect' do + context 'with valid path' do + it 'redirects based on wizard state' do + skip 'Complex wizard navigation logic - tested through actual wizard flow' + end + end + + context 'with invalid path' do + it 'handles invalid path safely' do + skip 'Route constraints prevent invalid paths from reaching controller' + end + end + end + + describe 'private methods' do + let(:controller) { described_class.new } + + describe '#permitted_path' do + it 'allows platform_details' do + expect(controller.send(:permitted_path, 'platform_details')).to eq('platform_details') + end + + it 'allows create_host_platform' do + expect(controller.send(:permitted_path, 'create_host_platform')).to eq('create_host_platform') + end + + it 'allows admin_creation' do + expect(controller.send(:permitted_path, 'admin_creation')).to eq('admin_creation') + end + + it 'allows create_admin' do + expect(controller.send(:permitted_path, 'create_admin')).to eq('create_admin') + end + + it 'returns nil for invalid path' do + expect(controller.send(:permitted_path, 'invalid_path')).to be_nil + end + end + + describe '#base_platform' do + before do + # rubocop:disable RSpec/MessageChain + allow(controller).to receive_message_chain(:helpers, :base_url).and_return('http://test.example.com') + # rubocop:enable RSpec/MessageChain + end + + it 'creates a platform with default attributes' do + platform = controller.send(:base_platform) + expect(platform).to be_a(Platform) + expect(platform.privacy).to eq('private') + expect(platform.protected).to be true + expect(platform.host).to be true + expect(platform.time_zone).to eq(Time.zone.name) + end + end + end + end +end +# rubocop:enable Metrics/ModuleLength diff --git a/spec/requests/better_together/translations_controller_spec.rb b/spec/requests/better_together/translations_controller_spec.rb new file mode 100644 index 000000000..452a1a656 --- /dev/null +++ b/spec/requests/better_together/translations_controller_spec.rb @@ -0,0 +1,211 @@ +# frozen_string_literal: true + +require 'rails_helper' + +# rubocop:disable Metrics/ModuleLength +module BetterTogether + RSpec.describe TranslationsController, :as_user do + describe 'POST #translate' do + let(:person) { BetterTogether::User.find_by(email: 'user@example.test')&.person } + let(:content) { 'Hello, world!' } + let(:source_locale) { 'en' } + let(:target_locale) { 'es' } + let(:translated_content) { '¡Hola, mundo!' } + let(:translation_bot) { instance_double(BetterTogether::TranslationBot) } + + let(:valid_params) do + { + content:, + source_locale:, + target_locale: + } + end + + before do + # Stub TranslationBot.new to return our mock instance + allow(BetterTogether::TranslationBot).to receive(:new).and_return(translation_bot) + end + + context 'with successful translation' do + before do + allow(translation_bot).to receive(:translate) + .with(content, + target_locale:, + source_locale:, + initiator: person) + .and_return(translated_content) + + post better_together.ai_translate_path(locale: I18n.default_locale), + params: valid_params + end + + it 'returns http success' do + expect(response).to have_http_status(:success) + end + + it 'returns translated content as JSON' do + expect(response.content_type).to match(%r{application/json}) + json_response = JSON.parse(response.body) + expect(json_response['translation']).to eq(translated_content) + end + + it 'calls TranslationBot with correct parameters' do + expect(translation_bot).to have_received(:translate) + .with(content, + target_locale:, + source_locale:, + initiator: person) + end + end + + context 'with different locales' do + let(:source_locale) { 'en' } + let(:target_locale) { 'fr' } + let(:translated_content) { 'Bonjour le monde!' } + + before do + allow(translation_bot).to receive(:translate) + .and_return(translated_content) + + post better_together.ai_translate_path(locale: I18n.default_locale), + params: valid_params + end + + it 'returns the French translation' do + json_response = JSON.parse(response.body) + expect(json_response['translation']).to eq(translated_content) + end + end + + context 'with complex HTML content' do + let(:content) do + ' ' + end + let(:translated_content) do + 'Hello
This is a test
' + end + + before do + allow(translation_bot).to receive(:translate) + .and_return(translated_content) + + post better_together.ai_translate_path(locale: I18n.default_locale), + params: valid_params + end + + it 'handles HTML content correctly' do + json_response = JSON.parse(response.body) + expect(json_response['translation']).to eq(translated_content) + end + end + + context 'when translation fails' do + before do + allow(translation_bot).to receive(:translate) + .and_raise(StandardError, 'API connection failed') + + post better_together.ai_translate_path(locale: I18n.default_locale), + params: valid_params + end + + it 'returns unprocessable_content status' do + expect(response).to have_http_status(:unprocessable_content) + end + + it 'returns error message as JSON' do + json_response = JSON.parse(response.body) + expect(json_response['error']).to eq('Translation failed: API connection failed') + end + end + + context 'when TranslationBot raises timeout error' do + before do + allow(translation_bot).to receive(:translate) + .and_raise(Timeout::Error) + + post better_together.ai_translate_path(locale: I18n.default_locale), + params: valid_params + end + + it 'handles the error gracefully' do + expect(response).to have_http_status(:unprocessable_content) + json_response = JSON.parse(response.body) + expect(json_response['error']).to include('Translation failed') + end + end + + context 'when content is empty' do + let(:content) { '' } + let(:translated_content) { '' } + + before do + allow(translation_bot).to receive(:translate) + .and_return(translated_content) + + post better_together.ai_translate_path(locale: I18n.default_locale), + params: valid_params + end + + it 'handles empty content' do + expect(response).to have_http_status(:success) + json_response = JSON.parse(response.body) + expect(json_response['translation']).to eq('') + end + end + + context 'when current_person is nil' do + it 'handles nil initiator and returns successful translation' do + skip 'Route requires authentication, so current_person cannot be nil in practice' + end + end + + context 'with missing parameters' do + it 'handles missing content parameter' do + allow(translation_bot).to receive(:translate).and_return('') + + post better_together.ai_translate_path(locale: I18n.default_locale), + params: { source_locale:, target_locale: } + + expect(response).to have_http_status(:success) + end + + it 'handles missing source_locale parameter' do + allow(translation_bot).to receive(:translate).and_return(translated_content) + + post better_together.ai_translate_path(locale: I18n.default_locale), + params: { content:, target_locale: } + + expect(response).to have_http_status(:success) + end + + it 'handles missing target_locale parameter' do + allow(translation_bot).to receive(:translate).and_return(translated_content) + + post better_together.ai_translate_path(locale: I18n.default_locale), + params: { content:, source_locale: } + + expect(response).to have_http_status(:success) + end + end + + context 'with special characters in content' do + let(:content) { "Hello & welcome toHola
Esta es una prueba
'world'!" } + let(:translated_content) { "¡Hola & bienvenido a 'mundo'!" } + + before do + allow(translation_bot).to receive(:translate) + .and_return(translated_content) + + post better_together.ai_translate_path(locale: I18n.default_locale), + params: valid_params + end + + it 'preserves special characters' do + json_response = JSON.parse(response.body) + expect(json_response['translation']).to eq(translated_content) + end + end + end + end +end +# rubocop:enable Metrics/ModuleLength diff --git a/spec/requests/better_together/users/registrations_spec.rb b/spec/requests/better_together/users/registrations_spec.rb index b8c35807f..24992b7eb 100644 --- a/spec/requests/better_together/users/registrations_spec.rb +++ b/spec/requests/better_together/users/registrations_spec.rb @@ -87,9 +87,10 @@ privacy_policy_agreement: '1', code_of_conduct_agreement: '1' } - end.to change(BetterTogether::User, :count).by(1) # User created despite empty name + end.not_to change(BetterTogether::User, :count) # User not created due to invalid person - expect(response).to have_http_status(:ok) # Form re-rendered with errors + expect(response).to have_http_status(:unprocessable_content) # Validation failed + expect(response.body).to include('can't be blank') # Name validation error shown end end diff --git a/spec/sanitizers/better_together/sanitizers/external_link_icon_sanitizer_spec.rb b/spec/sanitizers/better_together/sanitizers/external_link_icon_sanitizer_spec.rb new file mode 100644 index 000000000..061b0d67d --- /dev/null +++ b/spec/sanitizers/better_together/sanitizers/external_link_icon_sanitizer_spec.rb @@ -0,0 +1,299 @@ +# frozen_string_literal: true + +require 'rails_helper' + +module BetterTogether + # rubocop:disable Metrics/ModuleLength + module Sanitizers + RSpec.describe ExternalLinkIconSanitizer do + let(:sanitizer) { described_class.new } + let(:host) { 'example.com' } + + before do + allow(Rails.application.routes.default_url_options).to receive(:[]).with(:host).and_return(host) + end + + describe '#sanitize' do + context 'with internal links' do + it 'does not add icon to same-host links' do + html = 'Internal Link' + result = sanitizer.sanitize(html) + + expect(result).not_to include('fa-external-link-alt') + expect(result).not_to include('external-link') + end + + it 'does not modify relative links' do + html = 'About' + result = sanitizer.sanitize(html) + + expect(result).not_to include('fa-external-link-alt') + end + + it 'handles links without protocol' do + html = 'Page' + result = sanitizer.sanitize(html) + + expect(result).not_to include('fa-external-link-alt') + end + + it 'handles hash links' do + html = 'Section' + result = sanitizer.sanitize(html) + + expect(result).not_to include('fa-external-link-alt') + end + end + + context 'with external links' do + it 'adds Font Awesome icon to external links' do + html = 'External Link' + result = sanitizer.sanitize(html) + + expect(result).to include('fa-external-link-alt') + expect(result).to include('fas') + end + + it 'adds external-link class' do + html = 'External Link' + result = sanitizer.sanitize(html) + + expect(result).to include('class="external-link"') + end + + it 'appends icon after link text' do + html = 'External Link' + result = sanitizer.sanitize(html) + + # Icon should be after the text + expect(result).to match(/External Link.* + Internal + External + Local + 
'
+ result = sanitizer.sanitize(html)
+
+ expect(result).to include('fa-external-link-alt')
+ end
+
+ it 'handles multiple links in complex structure' do
+ html = <<~HTML
+
+ HTML
+ result = sanitizer.sanitize(html)
+
+ expect(result.scan('fa-external-link-alt').count).to eq(1)
+ end
+ end
+
+ context 'with sanitizer options' do
+ it 'passes options to parent sanitize method' do
+ html = 'Link'
+ result = sanitizer.sanitize(html)
+
+ # Should sanitize the script tag while preserving the link
+ expect(result).not_to include(' - ')
+ end
+
+ it 'renders blockquotes' do
+ markdown = '> This is a quote'
+
+ post preview_path,
+ params: { markdown: markdown },
+ as: :json
+
+ expect(response).to have_http_status(:ok)
+ json_response = JSON.parse(response.body)
+ expect(json_response['html']).to include('
Test
') + cached = block.cached_content + + expect(cached).to have_key(:id) + expect(cached).to have_key(:type) + expect(cached).to have_key(:content) + expect(cached).to have_key(:translations) + end + + it 'includes the block id and type' do + block = create(:better_together_content_html) + cached = block.cached_content + + expect(cached[:id]).to eq(block.id) + expect(cached[:type]).to eq('BetterTogether::Content::Html') + end + end + end + + describe 'Class Methods' do + # Class methods tested on both abstract base and concrete subclasses + describe '.block_name' do + it 'returns underscored class name for concrete types' do + expect(BetterTogether::Content::Html.block_name).to eq('html') + expect(BetterTogether::Content::Hero.block_name).to eq('hero') + expect(BetterTogether::Content::RichText.block_name).to eq('rich_text') + end + end + + describe '.content_addable?' do + it 'returns true for base Block class' do + expect(described_class.content_addable?).to be true + end + + it 'returns true for concrete subclasses' do + expect(BetterTogether::Content::Html.content_addable?).to be true + expect(BetterTogether::Content::Hero.content_addable?).to be true + end + end + + describe '.inherited' do + it 'includes BlockAttributes in subclasses' do + expect(BetterTogether::Content::Html.included_modules).to include(BetterTogether::Content::BlockAttributes) + expect(BetterTogether::Content::Hero.included_modules).to include(BetterTogether::Content::BlockAttributes) + end + end + + describe '.storext_keys' do + it 'returns an array of storext definition keys' do + keys = described_class.storext_keys + expect(keys).to be_an(Array) + end + + it 'includes keys from all block types' do + keys = described_class.storext_keys + # Keys are from all descendants, checking for presence of common ones + expect(keys).not_to be_empty + expect(keys).to be_an(Array) + end + end + + describe '.extra_permitted_attributes' do + it 'returns an array' do + expect(described_class.extra_permitted_attributes).to be_an(Array) + end + + it 'includes background_image_file' do + expect(described_class.extra_permitted_attributes).to include(:background_image_file) + end + + it 'includes attributes from descendants' do + attrs = described_class.extra_permitted_attributes + # Image adds :media to permitted attributes + expect(attrs).to include(:media) + # HTML adds :html_content + expect(attrs).to include(:html_content) + end + + it 'returns unique attributes' do + attrs = described_class.extra_permitted_attributes + expect(attrs.length).to eq(attrs.uniq.length) + end + end + + describe '.localized_block_attributes' do + it 'returns an array of localized attributes from all descendants' do + attrs = described_class.localized_block_attributes + expect(attrs).to be_an(Array) + end + + it 'includes localized attributes from subclasses' do + attrs = described_class.localized_block_attributes + # Hero has heading, content, cta_text + # Html has content + # RichText has content + # These should all be in the list + expect(attrs).not_to be_empty + end + end + end + + describe 'STI (Single Table Inheritance) Pattern' do + it 'Block is an abstract base class for content block types' do + # All blocks share the same table but have different types + html = create(:better_together_content_html) + hero = create(:better_together_content_hero) + css = create(:better_together_content_css) + + expect(html.type).to eq('BetterTogether::Content::Html') + expect(hero.type).to eq('BetterTogether::Content::Hero') + expect(css.type).to eq('BetterTogether::Content::Css') + + # All stored in same table + expect(html.class.table_name).to eq(hero.class.table_name) + expect(html.class.table_name).to eq(css.class.table_name) + end + + it 'queries on base Block class return all concrete types' do + html = create(:better_together_content_html) + hero = create(:better_together_content_hero) + css = create(:better_together_content_css) + + all_blocks = described_class.where(id: [html.id, hero.id, css.id]) + expect(all_blocks.count).to eq(3) + expect(all_blocks.map(&:class)).to contain_exactly( + BetterTogether::Content::Html, + BetterTogether::Content::Hero, + BetterTogether::Content::Css + ) + end + + it 'each concrete type is a descendant of Block' do + expect(BetterTogether::Content::Html.superclass).to eq(described_class) + expect(BetterTogether::Content::Hero.superclass).to eq(described_class) + expect(BetterTogether::Content::Css.superclass).to eq(described_class) + expect(BetterTogether::Content::RichText.superclass).to eq(described_class) + expect(BetterTogether::Content::Image.superclass).to eq(described_class) + end + end + end + end +end diff --git a/spec/models/better_together/content/css_spec.rb b/spec/models/better_together/content/css_spec.rb new file mode 100644 index 000000000..7e9375095 --- /dev/null +++ b/spec/models/better_together/content/css_spec.rb @@ -0,0 +1,59 @@ +# frozen_string_literal: true + +require 'rails_helper' + +module BetterTogether + module Content + RSpec.describe Css do + describe 'Factory' do + it 'has a valid factory' do + css_block = build(:better_together_content_css) + expect(css_block).to be_valid + end + + it 'creates with custom CSS content' do + css_block = create(:better_together_content_css, content_text: '.custom { color: blue; }') + expect(css_block.content).to eq('.custom { color: blue; }') + end + end + + describe 'Associations' do + it { is_expected.to have_many(:page_blocks).dependent(:destroy) } + it { is_expected.to have_many(:pages).through(:page_blocks) } + end + + describe 'Translatable Attributes' do + it { is_expected.to respond_to(:content) } + + it 'supports translations for CSS content' do + css_block = create(:better_together_content_css) + + I18n.with_locale(:en) do + css_block.content = '.en-class { color: red; }' + css_block.save! + end + + I18n.with_locale(:fr) do + css_block.content = '.fr-class { couleur: bleu; }' + css_block.save! + end + + expect(css_block.content_en).to eq('.en-class { color: red; }') + expect(css_block.content_fr).to eq('.fr-class { couleur: bleu; }') + end + end + + describe 'Store Attributes' do + describe 'css_settings' do + it { is_expected.to respond_to(:css_settings) } + end + end + + describe 'Inheritance' do + it 'inherits from Block' do + expect(described_class.superclass).to eq(Block) + end + end + end + end +end diff --git a/spec/models/better_together/content/hero_spec.rb b/spec/models/better_together/content/hero_spec.rb new file mode 100644 index 000000000..b78151570 --- /dev/null +++ b/spec/models/better_together/content/hero_spec.rb @@ -0,0 +1,173 @@ +# frozen_string_literal: true + +require 'rails_helper' + +module BetterTogether + module Content # rubocop:todo Metrics/ModuleLength + RSpec.describe Hero do + describe 'Factory' do + it 'has a valid factory' do + hero = build(:content_hero) + expect(hero).to be_valid + end + + it 'supports custom title and subtitle' do + hero = create(:content_hero, title: 'Custom Heading', subtitle: 'Custom Content') + expect(hero.heading).to eq('Custom Heading') + expect(hero.content.to_plain_text).to include('Custom Content') + end + end + + describe 'Associations' do + it { is_expected.to have_many(:page_blocks).dependent(:destroy) } + it { is_expected.to have_many(:pages).through(:page_blocks) } + end + + describe 'Translatable Attributes' do + it { is_expected.to respond_to(:heading) } + it { is_expected.to respond_to(:cta_text) } + it { is_expected.to respond_to(:content) } + + it 'supports translations for heading' do + hero = create(:content_hero) + + I18n.with_locale(:en) do + hero.heading = 'English Heading' + hero.save! + end + + I18n.with_locale(:fr) do + hero.heading = 'Titre Français' + hero.save! + end + + expect(hero.heading_en).to eq('English Heading') + expect(hero.heading_fr).to eq('Titre Français') + end + end + + describe 'Store Attributes' do + describe 'content_data' do + it { is_expected.to respond_to(:cta_url) } + + it 'can set cta_url' do + hero = create(:content_hero, cta_url: 'https://example.com') + expect(hero.cta_url).to eq('https://example.com') + end + end + + describe 'css_settings' do + it { is_expected.to respond_to(:css_classes) } + it { is_expected.to respond_to(:container_class) } + it { is_expected.to respond_to(:overlay_color) } + it { is_expected.to respond_to(:overlay_opacity) } + it { is_expected.to respond_to(:heading_color) } + it { is_expected.to respond_to(:paragraph_color) } + it { is_expected.to respond_to(:cta_button_style) } + + it 'has default values' do + hero = build(:content_hero) + expect(hero.css_classes).to eq('text-white') + expect(hero.container_class).to eq('') + expect(hero.overlay_color).to eq('#000') + expect(hero.overlay_opacity).to eq(0.25) + expect(hero.heading_color).to eq('') + expect(hero.paragraph_color).to eq('') + expect(hero.cta_button_style).to eq('btn-primary') + end + end + end + + describe 'Validations' do + describe 'cta_button_style' do + it 'validates inclusion in AVAILABLE_BTN_CLASSES values' do + hero = build(:content_hero, cta_button_style: 'invalid-class') + expect(hero).not_to be_valid + expect(hero.errors[:cta_button_style]).to include('is not included in the list') + end + + it 'accepts valid button classes' do + BetterTogether::Content::Hero::AVAILABLE_BTN_CLASSES.each_value do |btn_class| + hero = build(:content_hero, cta_button_style: btn_class) + expect(hero).to be_valid + end + end + end + end + + describe 'Instance Methods' do + describe '#overlay_styles' do + it 'returns hash with background_color and opacity' do + hero = create(:content_hero, overlay_color: '#FF0000', overlay_opacity: 0.5) + styles = hero.overlay_styles + + expect(styles).to be_a(Hash) + expect(styles[:background_color]).to eq('#FF0000') + expect(styles[:opacity]).to eq(0.5) + end + end + + describe '#inline_overlay_styles' do + it 'returns CSS inline style string' do + hero = create(:content_hero, overlay_color: '#00FF00', overlay_opacity: 0.75) + inline_styles = hero.inline_overlay_styles + + expect(inline_styles).to be_a(String) + expect(inline_styles).to include('background-color') + expect(inline_styles).to include('#00FF00') + expect(inline_styles).to include('opacity') + expect(inline_styles).to include('0.75') + end + end + end + + describe 'Constants' do + describe 'AVAILABLE_BTN_CLASSES' do + it 'includes primary button variants' do + expect(BetterTogether::Content::Hero::AVAILABLE_BTN_CLASSES).to include( + primary: 'btn-primary', + primary_outline: 'btn-outline-primary' + ) + end + + it 'includes all Bootstrap button variants' do + expected_keys = %i[primary primary_outline secondary secondary_outline success success_outline + info info_outline warning warning_outline danger danger_outline + light light_outline dark dark_outline] + + expect(BetterTogether::Content::Hero::AVAILABLE_BTN_CLASSES.keys).to match_array(expected_keys) + end + end + end + + describe 'Factory Traits' do + it 'supports primary_button trait' do + hero = create(:content_hero, :primary_button) + expect(hero.cta_button_style).to eq('btn-primary') + end + + it 'supports secondary_button trait' do + hero = create(:content_hero, :secondary_button) + expect(hero.cta_button_style).to eq('btn-secondary') + end + + it 'supports dark_overlay trait' do + hero = create(:content_hero, :dark_overlay) + expect(hero.overlay_color).to eq('#000') + expect(hero.overlay_opacity).to eq(0.5) + end + + it 'supports light_overlay trait' do + hero = create(:content_hero, :light_overlay) + expect(hero.overlay_color).to eq('#fff') + expect(hero.overlay_opacity).to eq(0.3) + end + + it 'supports with_background_image trait' do + hero = create(:content_hero, :with_background_image) + expect(hero.background_image_file).to be_attached + end + end + end + end +end diff --git a/spec/models/better_together/content/html_spec.rb b/spec/models/better_together/content/html_spec.rb new file mode 100644 index 000000000..10a440841 --- /dev/null +++ b/spec/models/better_together/content/html_spec.rb @@ -0,0 +1,72 @@ +# frozen_string_literal: true + +require 'rails_helper' + +module BetterTogether + module Content + RSpec.describe Html do + describe 'Factory' do + it 'has a valid factory' do + html_block = build(:better_together_content_html) + expect(html_block).to be_valid + end + + it 'creates with custom content' do + html_block = create(:better_together_content_html, content: 'Custom HTML content
') + expect(html_block.content).to eq('Custom HTML content
') + end + end + + describe 'Associations' do + it { is_expected.to have_many(:page_blocks).dependent(:destroy) } + it { is_expected.to have_many(:pages).through(:page_blocks) } + end + + describe 'Translatable Attributes' do + it { is_expected.to respond_to(:content) } + + it 'supports translations for content' do + html_block = create(:better_together_content_html) + + I18n.with_locale(:en) do + html_block.content = 'English HTML
' + html_block.save! + end + + I18n.with_locale(:fr) do + html_block.content = 'HTML Français
' + html_block.save! + end + + expect(html_block.content_en).to eq('English HTML
') + expect(html_block.content_fr).to eq('HTML Français
') + end + end + + describe 'Store Attributes' do + describe 'content_data' do + it { is_expected.to respond_to(:content_data) } + it { is_expected.to respond_to(:html_content) } + end + end + + describe 'Class Methods' do + describe '.extra_permitted_attributes' do + it 'returns an array' do + expect(described_class.extra_permitted_attributes).to be_an(Array) + end + + it 'includes html_content attribute' do + expect(described_class.extra_permitted_attributes).to include(:html_content) + end + end + end + + describe 'Inheritance' do + it 'inherits from Block' do + expect(described_class.superclass).to eq(Block) + end + end + end + end +end diff --git a/spec/models/better_together/content/image_spec.rb b/spec/models/better_together/content/image_spec.rb new file mode 100644 index 000000000..c66c6665f --- /dev/null +++ b/spec/models/better_together/content/image_spec.rb @@ -0,0 +1,223 @@ +# frozen_string_literal: true + +require 'rails_helper' + +module BetterTogether + module Content # rubocop:todo Metrics/ModuleLength + RSpec.describe Image do + describe 'Factory' do + it 'has a valid factory' do + image_block = build(:better_together_content_image) + expect(image_block).to be_valid + end + + it 'creates with attached media' do + image_block = create(:better_together_content_image) + expect(image_block.media).to be_attached + end + + it 'creates with caption and attribution' do + image_block = create(:better_together_content_image, + caption: 'Test caption', + attribution: 'Test photographer') + expect(image_block.caption).to eq('Test caption') + expect(image_block.attribution).to eq('Test photographer') + end + end + + describe 'Associations' do + it { is_expected.to have_many(:page_blocks).dependent(:destroy) } + it { is_expected.to have_many(:pages).through(:page_blocks) } + end + + describe 'Active Storage Attachment' do + it 'has one attached media file' do + image_block = create(:better_together_content_image) + expect(image_block.media).to be_attached + expect(image_block.media.filename.to_s).to eq('test-image.png') + end + + it 'delegates url to media' do + # Set ActiveStorage url_options for test environment + ActiveStorage::Current.url_options = { host: 'localhost', port: 3000, protocol: 'http' } + + image_block = create(:better_together_content_image) + expect(image_block).to respond_to(:url) + expect(image_block.url).to be_present + expect(image_block.url).to include('test-image.png') + end + end + + describe 'Validations' do + describe 'media presence' do + it 'requires media attachment' do + image_block = build(:better_together_content_image) + image_block.media.purge + expect(image_block).not_to be_valid + expect(image_block.errors[:media]).to include("can't be blank") + end + end + + describe 'attribution_url format' do + it 'accepts valid HTTP URLs' do + image_block = build(:better_together_content_image, attribution_url: 'http://example.com') + expect(image_block).to be_valid + end + + it 'accepts valid HTTPS URLs' do + image_block = build(:better_together_content_image, attribution_url: 'https://example.com') + expect(image_block).to be_valid + end + + it 'accepts URLs with paths' do + image_block = build(:better_together_content_image, + attribution_url: 'https://example.com/path/to/image') + expect(image_block).to be_valid + end + + it 'allows blank attribution_url' do + image_block = build(:better_together_content_image, attribution_url: '') + expect(image_block).to be_valid + end + + it 'rejects invalid URLs' do + image_block = build(:better_together_content_image, attribution_url: 'not a url') + expect(image_block).not_to be_valid + expect(image_block.errors[:attribution_url]).to be_present + end + + it 'rejects URLs without protocol' do + image_block = build(:better_together_content_image, attribution_url: 'example.com') + expect(image_block).not_to be_valid + end + end + + describe 'media content type' do + it 'accepts JPEG images' do + image_block = build(:better_together_content_image, :with_jpg) + expect(image_block).to be_valid + end + + it 'accepts GIF images' do + image_block = build(:better_together_content_image, :with_gif) + expect(image_block).to be_valid + end + + it 'accepts WebP images' do + image_block = build(:better_together_content_image, :with_webp) + expect(image_block).to be_valid + end + end + end + + describe 'Translatable Attributes' do + it { is_expected.to respond_to(:attribution) } + it { is_expected.to respond_to(:alt_text) } + it { is_expected.to respond_to(:caption) } + + it 'supports translations for attribution' do + image_block = create(:better_together_content_image) + + I18n.with_locale(:en) do + image_block.attribution = 'English Photographer' + image_block.save! + end + + I18n.with_locale(:fr) do + image_block.attribution = 'Photographe Français' + image_block.save! + end + + expect(image_block.attribution_en).to eq('English Photographer') + expect(image_block.attribution_fr).to eq('Photographe Français') + end + + it 'supports translations for alt_text' do + image_block = create(:better_together_content_image) + + I18n.with_locale(:en) do + image_block.alt_text = 'English description' + image_block.save! + end + + I18n.with_locale(:es) do + image_block.alt_text = 'Descripción en español' + image_block.save! + end + + expect(image_block.alt_text_en).to eq('English description') + expect(image_block.alt_text_es).to eq('Descripción en español') + end + + it 'supports translations for caption' do + image_block = create(:better_together_content_image) + + I18n.with_locale(:en) do + image_block.caption = 'English caption' + image_block.save! + end + + I18n.with_locale(:fr) do + image_block.caption = 'Légende française' + image_block.save! + end + + expect(image_block.caption_en).to eq('English caption') + expect(image_block.caption_fr).to eq('Légende française') + end + end + + describe 'Store Attributes' do + describe 'media_settings' do + it { is_expected.to respond_to(:media_settings) } + it { is_expected.to respond_to(:attribution_url) } + + it 'can store attribution_url' do + image_block = create(:better_together_content_image) + image_block.update(attribution_url: 'https://example.com/photo') + expect(image_block.attribution_url).to eq('https://example.com/photo') + end + + it 'has default empty string for attribution_url' do + image_block = create(:better_together_content_image, attribution_url: nil) + image_block.reload + # Store attributes default to empty string per model definition + expect(image_block.attribution_url).to eq('').or be_nil + end + end + end + + describe 'Class Methods' do + describe '.content_addable?' do + it 'returns true' do + expect(described_class.content_addable?).to be true + end + end + + describe '.extra_permitted_attributes' do + it 'includes media attribute' do + expect(described_class.extra_permitted_attributes).to include(:media) + end + end + end + + describe 'Constants' do + describe 'CONTENT_TYPES' do + it 'includes common image formats' do + expect(Image::CONTENT_TYPES).to include('image/jpeg') + expect(Image::CONTENT_TYPES).to include('image/png') + expect(Image::CONTENT_TYPES).to include('image/gif') + expect(Image::CONTENT_TYPES).to include('image/webp') + expect(Image::CONTENT_TYPES).to include('image/svg+xml') + end + end + end + + describe 'Inheritance' do + it 'inherits from Block' do + expect(described_class.superclass).to eq(Block) + end + end + end + end +end diff --git a/spec/models/better_together/content/link_spec.rb b/spec/models/better_together/content/link_spec.rb new file mode 100644 index 000000000..3741ff331 --- /dev/null +++ b/spec/models/better_together/content/link_spec.rb @@ -0,0 +1,113 @@ +# frozen_string_literal: true + +require 'rails_helper' + +module BetterTogether + module Content + RSpec.describe Link do + describe 'Factory' do + it 'has a valid factory' do + link = build(:content_link) + expect(link).to be_valid + end + + it 'creates with default attributes' do + link = create(:content_link) + expect(link.link_type).to eq('website') + expect(link.valid_link).to be false + expect(link.scheme).to eq('https') + expect(link.host).to be_present + end + + it 'creates with custom URL' do + link = create(:content_link, url: 'https://custom.example.com/path') + expect(link.url).to eq('https://custom.example.com/path') + expect(link.host).to eq('custom.example.com') + end + end + + describe 'Associations' do + it { is_expected.to have_many(:rich_text_links).class_name('BetterTogether::Metrics::RichTextLink') } + it { is_expected.to have_many(:rich_texts).through(:rich_text_links) } + + # NOTE: rich_text_records association is polymorphic and requires source_type + # It's tested indirectly through the has_many :rich_text_links association + end + + describe 'Initialization defaults' do + it 'sets link_type to "website" when blank' do + link = described_class.new + expect(link.link_type).to eq('website') + end + + it 'does not override provided link_type' do + link = described_class.new(link_type: 'external') + expect(link.link_type).to eq('external') + end + + it 'sets valid_link to false when nil' do + link = described_class.new + expect(link.valid_link).to be false + end + + it 'does not override provided valid_link value' do + link = described_class.new(valid_link: true) + expect(link.valid_link).to be true + end + end + + describe 'Attributes' do + it 'stores URL' do + link = create(:content_link, url: 'https://example.com/page') + expect(link.url).to eq('https://example.com/page') + end + + it 'stores scheme' do + link = create(:content_link, scheme: 'http') + expect(link.scheme).to eq('http') + end + + it 'stores host' do + link = create(:content_link, host: 'example.org') + expect(link.host).to eq('example.org') + end + + it 'tracks external status' do + external_link = create(:content_link, external: true) + internal_link = create(:content_link, external: false) + + expect(external_link.external).to be true + expect(internal_link.external).to be false + end + + it 'tracks link validity' do + valid_link = create(:content_link, valid_link: true) + invalid_link = create(:content_link, valid_link: false) + + expect(valid_link.valid_link).to be true + expect(invalid_link.valid_link).to be false + end + end + + describe 'Link metadata tracking' do + it 'can distinguish between internal and external links' do + internal = create(:content_link, external: false, url: 'https://mysite.com/page') + external = create(:content_link, external: true, url: 'https://othersite.com/page') + + expect(internal.external).to be false + expect(external.external).to be true + end + + it 'supports different link types' do + website = create(:content_link, link_type: 'website') + email = create(:content_link, link_type: 'email', url: 'mailto:test@example.com') + tel = create(:content_link, link_type: 'tel', url: 'tel:+1234567890') + + expect(website.link_type).to eq('website') + expect(email.link_type).to eq('email') + expect(tel.link_type).to eq('tel') + end + end + end + end +end diff --git a/spec/models/better_together/content/markdown_localization_spec.rb b/spec/models/better_together/content/markdown_localization_spec.rb new file mode 100644 index 000000000..ecbd327f4 --- /dev/null +++ b/spec/models/better_together/content/markdown_localization_spec.rb @@ -0,0 +1,308 @@ +# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe BetterTogether::Content::Markdown do + describe 'Mobility translations' do + subject(:markdown) { build(:content_markdown) } + + it 'includes Translatable concern' do + expect(described_class.ancestors).to include(BetterTogether::Translatable) + end + + it 'translates markdown_source attribute' do + expect(described_class.mobility_attributes).to include('markdown_source') + end + + it 'supports per-locale content' do + I18n.with_locale(:en) do + markdown.markdown_source = 'English content' + end + I18n.with_locale(:es) do + markdown.markdown_source = 'Contenido en español' + end + I18n.with_locale(:fr) do + markdown.markdown_source = 'Contenu en français' + end + + markdown.save! + + I18n.with_locale(:en) do + expect(markdown.markdown_source).to eq('English content') + end + I18n.with_locale(:es) do + expect(markdown.markdown_source).to eq('Contenido en español') + end + I18n.with_locale(:fr) do + expect(markdown.markdown_source).to eq('Contenu en français') + end + end + end + + describe '#content with localization' do + context 'when using translated markdown_source' do + let(:markdown) do + m = nil + I18n.with_locale(:en) do + m = create(:content_markdown, markdown_source: 'English content') + end + I18n.with_locale(:es) do + m.update!(markdown_source: 'Contenido en español') + end + m + end + + it 'returns content for current locale' do + I18n.with_locale(:en) do + expect(markdown.content).to eq('English content') + end + + I18n.with_locale(:es) do + expect(markdown.content).to eq('Contenido en español') + end + end + end + + context 'when using auto_sync_from_file with locale-specific files' do + let(:base_path) { Rails.root.join('spec/fixtures/files/localized_content.md') } + let(:markdown) do + create(:content_markdown, + markdown_source: 'Temp', + markdown_file_path: base_path.to_s, + auto_sync_from_file: true) + end + let(:en_file) { base_path.to_s.sub(/\.md$/i, '.en.md') } + let(:es_file) { base_path.to_s.sub(/\.md$/i, '.es.md') } + let(:fr_file) { base_path.to_s.sub(/\.md$/i, '.fr.md') } + + before do + FileUtils.mkdir_p(File.dirname(base_path)) + File.write(base_path, '# Base') + File.write(en_file, '# English Heading') + File.write(es_file, '# Título en Español') + File.write(fr_file, '# Titre en Français') + end + + after do + FileUtils.rm_f([base_path, en_file, es_file, fr_file]) + end + + it 'loads content for current locale from file' do + expect(markdown.content).to eq('# English Heading') + + I18n.with_locale(:es) do + expect(markdown.content).to eq('# Título en Español') + end + + I18n.with_locale(:fr) do + expect(markdown.content).to eq('# Titre en Français') + end + end + end + + context 'when using auto_sync_from_file with fallback' do + let(:base_path) { Rails.root.join('spec/fixtures/files/fallback_content') } + let(:default_file) { "#{base_path}.md" } + let(:en_file) { "#{base_path}.en.md" } + + let(:markdown) do + create(:content_markdown, + markdown_source: nil, + markdown_file_path: default_file, + auto_sync_from_file: true) + end + + before do + FileUtils.mkdir_p(File.dirname(default_file)) + File.write(en_file, '# English Content') + File.write(default_file, '# Default Content') + end + + after do + FileUtils.rm_f([default_file, en_file]) + end + + it 'falls back to default file when locale-specific not found' do + I18n.with_locale(:es) do + # No es file, should fall back to default + expect(markdown.content).to eq('# Default Content') + end + end + + it 'uses locale-specific file when available' do + expect(markdown.content).to eq('# English Content') + end + end + end + + describe '#import_file_content!' do + let(:base_path) { Rails.root.join('spec/fixtures/files/import_test') } + let(:base_file) { "#{base_path}.md" } + let(:en_file) { "#{base_path}.en.md" } + let(:es_file) { "#{base_path}.es.md" } + let(:fr_file) { "#{base_path}.fr.md" } + + let(:markdown) do + create(:content_markdown, + markdown_source: 'Temp', + markdown_file_path: base_file) + end + + before do + FileUtils.mkdir_p(File.dirname(base_file)) + File.write(base_file, '# Base') + File.write(en_file, '# English Import') + File.write(es_file, '# Importación Española') + File.write(fr_file, '# Importation Française') + end + + after do + FileUtils.rm_f([base_file, en_file, es_file, fr_file]) + end + + it 'imports content for all available locales' do + expect(markdown.import_file_content!).to be true + + expect(markdown.markdown_source).to eq('# English Import') + I18n.with_locale(:es) do + expect(markdown.markdown_source).to eq('# Importación Española') + end + I18n.with_locale(:fr) do + expect(markdown.markdown_source).to eq('# Importation Française') + end + end + + it 'sets auto_sync_from_file when requested' do + markdown.import_file_content!(sync_future_changes: true) + + expect(markdown.auto_sync_from_file).to be true + end + + it 'returns false when no file path' do + markdown.update!(markdown_file_path: nil) + + expect(markdown.import_file_content!).to be false + end + end + + describe '#as_indexed_json with localization' do + let(:markdown) do + m = nil + I18n.with_locale(:en) do + m = create(:content_markdown, markdown_source: '# English **content**') + end + I18n.with_locale(:es) do + m.update!(markdown_source: '# Contenido **español**') + end + I18n.with_locale(:fr) do + m.update!(markdown_source: '# Contenu **français**') + end + m + end + + it 'indexes content for all available locales' do + result = markdown.as_indexed_json + + expect(result[:localized_content][:en]).to include('English') + expect(result[:localized_content][:en]).to include('content') + expect(result[:localized_content][:en]).not_to include('**') + + expect(result[:localized_content][:es]).to include('Contenido') + expect(result[:localized_content][:es]).to include('español') + + expect(result[:localized_content][:fr]).to include('Contenu') + expect(result[:localized_content][:fr]).to include('français') + end + + it 'strips HTML from indexed content' do + result = markdown.as_indexed_json + + I18n.available_locales.each do |locale| + expect(result[:localized_content][locale]).not_to match(/<[^>]+>/) + end + end + end + + describe '#rendered_html with localization' do + let(:markdown) do + m = nil + I18n.with_locale(:en) do + m = create(:content_markdown, markdown_source: '# English') + end + I18n.with_locale(:es) do + m.update!(markdown_source: '# Español') + end + m + end + + it 'renders content for current locale' do + I18n.with_locale(:en) do + html = markdown.rendered_html + expect(html).to include('English') + end + + I18n.with_locale(:es) do + html = markdown.rendered_html + expect(html).to include('Español') + end + end + end + + describe '.permitted_attributes' do + it 'includes auto_sync_from_file' do + expect(described_class.permitted_attributes).to include(:auto_sync_from_file) + end + + it 'includes markdown_source and markdown_file_path' do + expect(described_class.permitted_attributes).to include(:markdown_source, :markdown_file_path) + end + end + + describe 'auto_sync_from_file behavior' do + context 'when auto_sync is disabled' do + let(:file_path) { Rails.root.join('spec/fixtures/files/no_sync.md') } + let(:markdown) do + create(:content_markdown, + markdown_source: 'Database content', + markdown_file_path: file_path.to_s, + auto_sync_from_file: false) + end + + before do + FileUtils.mkdir_p(File.dirname(file_path)) + File.write(file_path, '# File content') + end + + after do + FileUtils.rm_f(file_path) + end + + it 'uses database content instead of file' do + expect(markdown.content).to eq('Database content') + end + end + + context 'when auto_sync is enabled' do + let(:file_path) { Rails.root.join('spec/fixtures/files/with_sync.md') } + let(:markdown) do + create(:content_markdown, + markdown_source: 'Database content', + markdown_file_path: file_path.to_s, + auto_sync_from_file: true) + end + + before do + FileUtils.mkdir_p(File.dirname(file_path)) + File.write(file_path, '# File content') + end + + after do + FileUtils.rm_f(file_path) + end + + it 'loads content from file, ignoring database' do + expect(markdown.content).to eq('# File content') + end + end + end +end diff --git a/spec/models/better_together/content/markdown_spec.rb b/spec/models/better_together/content/markdown_spec.rb new file mode 100644 index 000000000..00282f9d4 --- /dev/null +++ b/spec/models/better_together/content/markdown_spec.rb @@ -0,0 +1,385 @@ +# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe BetterTogether::Content::Markdown do + describe 'associations' do + it { is_expected.to have_many(:page_blocks).dependent(:destroy) } + it { is_expected.to have_many(:pages).through(:page_blocks) } + end + + describe 'validations' do + context 'when markdown_source is provided' do + subject { described_class.new(markdown_source: '# Hello World') } + + it { is_expected.to be_valid } + it { is_expected.not_to validate_presence_of(:markdown_file_path) } + end + + context 'when markdown_file_path is provided' do + subject { described_class.new(markdown_file_path: file_path.to_s) } + + let(:file_path) { Rails.root.join('spec/fixtures/files/test_markdown.md') } + + before do + FileUtils.mkdir_p(File.dirname(file_path)) + File.write(file_path, '# Test Content') + end + + after do + FileUtils.rm_f(file_path) + end + + it { is_expected.to be_valid } + end + + context 'when neither source nor file_path is provided' do + subject(:markdown_block) { described_class.new } + + it 'is invalid' do + expect(markdown_block).not_to be_valid + expect(markdown_block.errors[:base]).to include('Either markdown source or file path must be provided') + end + end + + context 'when file_path does not exist' do + subject(:markdown_block) { described_class.new(markdown_file_path: '/nonexistent/file.md') } + + it 'is invalid' do + expect(markdown_block).not_to be_valid + expect(markdown_block.errors[:markdown_file_path]).to include('file does not exist') + end + end + + context 'when file_path has wrong extension' do + subject(:markdown_block) { described_class.new(markdown_file_path: file_path.to_s) } + + let(:file_path) { Rails.root.join('spec/fixtures/files/test_file.txt') } + + before do + FileUtils.mkdir_p(File.dirname(file_path)) + File.write(file_path, 'Some content') + end + + after do + FileUtils.rm_f(file_path) + end + + it 'is invalid' do + expect(markdown_block).not_to be_valid + expect(markdown_block.errors[:markdown_file_path]).to include('must be a markdown file (.md or .markdown)') + end + end + + context 'when file has .markdown extension' do + subject { described_class.new(markdown_file_path: file_path.to_s) } + + let(:file_path) { Rails.root.join('spec/fixtures/files/test.markdown') } + + before do + FileUtils.mkdir_p(File.dirname(file_path)) + File.write(file_path, '# Test') + end + + after do + FileUtils.rm_f(file_path) + end + + it { is_expected.to be_valid } + end + end + + describe '#content' do + context 'when using markdown_source' do + let(:markdown) { described_class.new(markdown_source: '# Hello **World**') } + + it 'returns the markdown_source' do + expect(markdown.content).to eq('# Hello **World**') + end + end + + context 'when using markdown_file_path' do + let(:file_path) { Rails.root.join('spec/fixtures/files/content_test.md') } + let(:markdown) { described_class.new(markdown_file_path: file_path.to_s) } + let(:file_content) { "# File Content\n\nThis is from a file." } + + before do + FileUtils.mkdir_p(File.dirname(file_path)) + File.write(file_path, file_content) + end + + after do + FileUtils.rm_f(file_path) + end + + it 'returns the file content' do + expect(markdown.content).to eq(file_content) + end + end + + context 'when using relative file path' do + let(:file_path) { 'spec/fixtures/files/relative_test.md' } + let(:markdown) { described_class.new(markdown_file_path: file_path) } + let(:full_path) { Rails.root.join(file_path) } + let(:file_content) { '# Relative Path Test' } + + before do + FileUtils.mkdir_p(File.dirname(full_path)) + File.write(full_path, file_content) + end + + after do + FileUtils.rm_f(full_path) + end + + it 'resolves the relative path' do + expect(markdown.content).to eq(file_content) + end + end + + context 'when file does not exist' do + let(:markdown) { described_class.new(markdown_file_path: '/tmp/nonexistent.md') } + + it 'returns empty string' do + # Skip validation + markdown.save(validate: false) + expect(markdown.content).to eq('') + end + end + + context 'when both source and file_path are provided' do + let(:file_path) { Rails.root.join('spec/fixtures/files/both_test.md') } + let(:markdown) do + described_class.new( + markdown_source: '# Source Content', + markdown_file_path: file_path.to_s + ) + end + + before do + FileUtils.mkdir_p(File.dirname(file_path)) + File.write(file_path, '# File Content') + end + + after do + FileUtils.rm_f(file_path) + end + + it 'prefers markdown_source' do + expect(markdown.content).to eq('# Source Content') + end + end + end + + describe '#rendered_html' do + let(:markdown) { described_class.new(markdown_source: markdown_source) } + + context 'with basic markdown' do + let(:markdown_source) { '# Hello World' } + + it 'renders markdown to HTML' do + html = markdown.rendered_html + expect(html).to include('- ')
+ expect(html).to include('