Improve specs

Author: rsmithlal

app/builders/better_together/access_control_builder.rb

@@ -16,23 +16,44 @@ def seed_data
       end
 
       def build_community_roles
-        ::BetterTogether::Role.create!(community_role_attrs)
+        community_role_attrs.each do |attrs|
+          # Idempotent: find by unique identifier and update attributes if needed
+          role = ::BetterTogether::Role.find_or_initialize_by(identifier: attrs[:identifier])
+          role.assign_attributes(attrs)
+          role.save! if role.changed?
+        end
       end
 
       def build_community_resource_permissions
-        ::BetterTogether::ResourcePermission.create!(community_resource_permission_attrs)
+        community_resource_permission_attrs.each do |attrs|
+          perm = ::BetterTogether::ResourcePermission.find_or_initialize_by(identifier: attrs[:identifier])
+          perm.assign_attributes(attrs)
+          perm.save! if perm.changed?
+        end
       end
 
       def build_platform_resource_permissions
-        ::BetterTogether::ResourcePermission.create!(platform_resource_permission_attrs)
+        platform_resource_permission_attrs.each do |attrs|
+          perm = ::BetterTogether::ResourcePermission.find_or_initialize_by(identifier: attrs[:identifier])
+          perm.assign_attributes(attrs)
+          perm.save! if perm.changed?
+        end
       end
 
       def build_platform_roles
-        ::BetterTogether::Role.create!(platform_role_attrs)
+        platform_role_attrs.each do |attrs|
+          role = ::BetterTogether::Role.find_or_initialize_by(identifier: attrs[:identifier])
+          role.assign_attributes(attrs)
+          role.save! if role.changed?
+        end
       end
 
       def build_person_resource_permissions
-        ::BetterTogether::ResourcePermission.create!(person_resource_permission_attrs)
+        person_resource_permission_attrs.each do |attrs|
+          perm = ::BetterTogether::ResourcePermission.find_or_initialize_by(identifier: attrs[:identifier])
+          perm.assign_attributes(attrs)
+          perm.save! if perm.changed?
+        end
       end
 
       # Clear existing data - Use with caution!

app/controllers/better_together/setup_wizard_controller.rb

@@ -4,7 +4,10 @@
 module BetterTogether
   # Handles the setup wizard process
   class SetupWizardController < WizardsController
-    def show; end
+    def show
+      # Always land on the first step of the host setup wizard
+      redirect_to setup_wizard_step_platform_details_path
+    end
 
     private
 

app/controllers/concerns/better_together/notification_readable.rb

@@ -7,41 +7,32 @@ module NotificationReadable
 
     # Marks notifications (for the current person) as read for events bound to a record
     # via Noticed::Event#record_id (generic helper used across features).
-    def mark_notifications_read_for_record(record, recipient: helpers.current_person) # rubocop:todo Metrics/AbcSize
+    def mark_notifications_read_for_record(record, recipient: helpers.current_person)
       return unless recipient && record.respond_to?(:id)
 
-      nn = Noticed::Notification.arel_table
-      ne = Noticed::Event.arel_table
-
-      join = nn.join(ne).on(ne[:id].eq(nn[:event_id])).join_sources
-
-      relation = Noticed::Notification
-                 .where(recipient:)
-                 .where(nn[:read_at].eq(nil))
-                 .joins(join)
-                 .where(ne[:record_id].eq(record.id))
+      event_ids = Noticed::Event.where(record_id: record.id).select(:id)
 
-      relation.update_all(read_at: Time.current)
+      Noticed::Notification
+        .where(recipient:)
+        .where(event_id: event_ids)
+        .where(read_at: nil)
+        .update_all(read_at: Time.current)
     end
 
     # Marks notifications as read for a set of records associated to a given Noticed event class
     # using the event's record_id field.
-    def mark_notifications_read_for_event_records(event_class, record_ids, recipient: helpers.current_person) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+    def mark_notifications_read_for_event_records(event_class, record_ids, recipient: helpers.current_person)
       return unless recipient && record_ids.present?
 
-      nn = Noticed::Notification.arel_table
-      ne = Noticed::Event.arel_table
-
-      join = nn.join(ne).on(ne[:id].eq(nn[:event_id])).join_sources
-
-      relation = Noticed::Notification
-                 .where(recipient:)
-                 .where(nn[:read_at].eq(nil))
-                 .joins(join)
-                 .where(ne[:type].eq(event_class.to_s))
-                 .where(ne[:record_id].in(Array(record_ids)))
+      event_ids = Noticed::Event
+                  .where(type: event_class.to_s, record_id: Array(record_ids))
+                  .select(:id)
 
-      relation.update_all(read_at: Time.current)
+      Noticed::Notification
+        .where(recipient:)
+        .where(event_id: event_ids)
+        .where(read_at: nil)
+        .update_all(read_at: Time.current)
     end
 
     # Marks Joatu match notifications as read for an Offer or Request record by matching

app/policies/better_together/calendar_policy.rb

@@ -4,11 +4,11 @@ module BetterTogether
   # Access control for calendars
   class CalendarPolicy < ApplicationPolicy
     def index?
-      user.present? && permitted_to?('manage_platform')
+      user.present?
     end
 
     def show?
-      user.present? && (record.creator == agent or permitted_to?('manage_platform'))
+      user.present?
     end
 
     def update?

app/services/better_together/joatu/matchmaker.rb

@@ -22,8 +22,8 @@ def self.match(record) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
                                    .where(BetterTogether::Joatu::Category.table_name => { id: record.category_ids })
           end
 
-          # Target type must align; target_id supports wildcard semantics
-          candidates = candidates.where(target_type: record.target_type)
+          # Target type must align when present; target_id supports wildcard semantics
+          candidates = candidates.where(target_type: record.target_type) if record.target_type.present?
           if record.target_id.present?
             candidates = candidates.where(
               "#{offer_klass.table_name}.target_id = ? OR #{offer_klass.table_name}.target_id IS NULL",
@@ -54,7 +54,7 @@ def self.match(record) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
                                    .where(BetterTogether::Joatu::Category.table_name => { id: record.category_ids })
           end
 
-          candidates = candidates.where(target_type: record.target_type)
+          candidates = candidates.where(target_type: record.target_type) if record.target_type.present?
           if record.target_id.present?
             candidates = candidates.where(
               "#{request_klass.table_name}.target_id = ? OR #{request_klass.table_name}.target_id IS NULL",

spec/factories/better_together/conversations.rb

@@ -8,7 +8,13 @@
     association :creator, factory: :person
 
     after(:build) do |conversation|
-      conversation.participants << conversation.creator
+      conversation.participants << conversation.creator unless conversation.participants.include?(conversation.creator)
+    end
+
+    after(:create) do |conversation|
+      unless conversation.participants.exists?(conversation.creator.id)
+        conversation.participants << conversation.creator
+      end
     end
   end
 end

spec/factories/better_together/platforms.rb

@@ -10,7 +10,8 @@
     name { Faker::Company.name }
     description { Faker::Lorem.paragraph }
     identifier { Faker::Internet.unique.username(specifier: 10..20) }
-    url { 'http://127.0.0.1:3000' }
+    # Ensure uniqueness to avoid validation collisions across specs
+    sequence(:url) { |n| "http://platform-#{n}.test" }
     host { false }
     time_zone { Faker::Address.time_zone }
     privacy { 'private' }

spec/rails_helper.rb

@@ -63,6 +63,7 @@
   config.include FactoryBot::Syntax::Methods
 
   config.include Devise::Test::IntegrationHelpers, type: :feature
+  config.include Devise::Test::IntegrationHelpers, type: :request
 
   config.include Warden::Test::Helpers
   config.after { Warden.test_reset! }

spec/requests/better_together/joatu/agreements_spec.rb

@@ -4,11 +4,12 @@
 
 # rubocop:disable Metrics/BlockLength
 RSpec.describe 'BetterTogether::Joatu::Agreements', :as_user do
-  let(:user) { create(:user, :confirmed) }
+  let(:user) { find_or_create_test_user('[email protected]', 'password12345', :user) }
+  let(:person) { user.person }
   let(:offer) { create(:joatu_offer) }
-  let(:request_record) { create(:joatu_request) }
+  let(:request_record) { create(:joatu_request, creator: person) }
   let(:valid_attributes) { { offer_id: offer.id, request_id: request_record.id, terms: 'terms', value: 'value' } }
-  let(:agreement) { create(:joatu_agreement) }
+  let(:agreement) { create(:joatu_agreement, offer: offer, request: request_record) }
 
   describe 'routing' do
     it 'routes to #index' do
@@ -54,7 +55,7 @@
 
   describe 'DELETE /destroy' do
     it 'destroys the agreement' do
-      to_delete = create(:joatu_agreement)
+      to_delete = create(:joatu_agreement, offer: offer, request: request_record)
       expect do
         delete better_together.joatu_agreement_path(to_delete, locale: I18n.locale)
       end.to change(BetterTogether::Joatu::Agreement, :count).by(-1)

spec/requests/better_together/joatu/offers_aggregated_matches_spec.rb

@@ -6,8 +6,10 @@
   # rubocop:todo RSpec/MultipleExpectations
   it 'shows Potential Matches for my offers with matching requests' do # rubocop:todo RSpec/ExampleLength, RSpec/MultipleExpectations
     # rubocop:enable RSpec/MultipleExpectations
-    # Current user creating an offer
-    current_user = BetterTogether::User.find_by(email: '[email protected]')
+    # Current authenticated user creating an offer
+    current_user = BetterTogether::User.find_by(email: '[email protected]') ||
+                   FactoryBot.create(:better_together_user, :confirmed,
+                                     email: '[email protected]', password: 'password12345')
     my_person = current_user.person
 
     # Ensure both records share a category so they match