test: improve coverage

Author: Bulletdev

spec/models/inhouse_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Inhouse, type: :model do
+  let(:organization) { create(:organization) }
+  let(:coach_user)   { create(:user, :coach, organization: organization) }
+
+  def build_inhouse(**attrs)
+    Inhouse.new({
+      organization: organization,
+      created_by: coach_user,
+      status: 'waiting'
+    }.merge(attrs))
+  end
+
+  def create_inhouse(**attrs)
+    build_inhouse(**attrs).tap(&:save!)
+  end
+
+  describe 'validations' do
+    it 'is valid with status waiting' do
+      expect(build_inhouse).to be_valid
+    end
+
+    it 'rejects invalid status values' do
+      expect { build_inhouse(status: 'invalid') }.to raise_error(ArgumentError)
+    end
+
+    it 'rejects invalid status transitions on update' do
+      inhouse = create_inhouse(status: 'waiting')
+      inhouse.update!(status: 'done')
+      inhouse.status = 'waiting'
+      expect(inhouse).not_to be_valid
+      expect(inhouse.errors[:status]).to be_present
+    end
+
+    it 'allows valid transition from waiting to draft' do
+      inhouse = create_inhouse(status: 'waiting')
+      inhouse.status = 'draft'
+      expect(inhouse).to be_valid
+    end
+
+    it 'allows valid transition from waiting to in_progress' do
+      inhouse = create_inhouse(status: 'waiting')
+      inhouse.status = 'in_progress'
+      expect(inhouse).to be_valid
+    end
+
+    it 'prevents illegal transition from in_progress to draft' do
+      inhouse = create_inhouse(status: 'waiting')
+      inhouse.update!(status: 'draft')
+      inhouse.update!(status: 'in_progress')
+      inhouse.status = 'draft'
+      expect(inhouse).not_to be_valid
+    end
+  end
+
+  describe 'scopes' do
+    it '.active includes waiting, draft, and in_progress statuses' do
+      waiting    = create_inhouse(status: 'waiting')
+      done_house = create_inhouse(status: 'waiting')
+      done_house.update!(status: 'done')
+
+      expect(Inhouse.active).to include(waiting)
+      expect(Inhouse.active).not_to include(done_house)
+    end
+
+    it '.history includes only done inhousess' do
+      waiting    = create_inhouse(status: 'waiting')
+      done_house = create_inhouse(status: 'waiting')
+      done_house.update!(status: 'done')
+
+      expect(Inhouse.history).to include(done_house)
+      expect(Inhouse.history).not_to include(waiting)
+    end
+  end
+
+  describe '#current_pick_team' do
+    it 'returns nil when status is not draft' do
+      expect(build_inhouse(status: 'waiting').current_pick_team).to be_nil
+    end
+
+    it 'returns the correct team for pick number 0 (blue first)' do
+      inhouse = create_inhouse(status: 'waiting')
+      inhouse.update_columns(status: 'draft', draft_pick_number: 0)
+      expect(inhouse.current_pick_team).to eq(Inhouse::PICK_ORDER[0])
+    end
+
+    it 'returns nil when all picks are exhausted' do
+      inhouse = create_inhouse(status: 'waiting')
+      inhouse.update_columns(status: 'draft', draft_pick_number: Inhouse::PICK_ORDER.size)
+      expect(inhouse.current_pick_team).to be_nil
+    end
+  end
+
+  describe '#draft_complete?' do
+    it 'returns true when pick number equals PICK_ORDER size' do
+      inhouse = build_inhouse(draft_pick_number: Inhouse::PICK_ORDER.size)
+      expect(inhouse.draft_complete?).to be(true)
+    end
+
+    it 'returns false when picks remain' do
+      inhouse = build_inhouse(draft_pick_number: 3)
+      expect(inhouse.draft_complete?).to be(false)
+    end
+
+    it 'returns false when draft_pick_number is nil' do
+      inhouse = build_inhouse(draft_pick_number: nil)
+      expect(inhouse.draft_complete?).to be(false)
+    end
+  end
+end

spec/models/organization_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Organization, type: :model do
+  subject { build(:organization) }
+
+  describe 'validations' do
+    it { is_expected.to validate_presence_of(:name) }
+
+    it 'rejects invalid region' do
+      org = build(:organization, region: 'INVALID')
+      expect(org).not_to be_valid
+      expect(org.errors[:region]).to be_present
+    end
+
+    it 'accepts all valid regions' do
+      Constants::REGIONS.each do |region|
+        org = build(:organization, region: region)
+        expect(org).to be_valid, "expected region #{region} to be valid"
+      end
+    end
+
+    it 'rejects invalid tier' do
+      org = build(:organization, tier: 'invalid_tier')
+      expect(org).not_to be_valid
+    end
+
+    it 'accepts blank tier' do
+      org = build(:organization, tier: nil)
+      expect(org).to be_valid
+    end
+  end
+
+  describe 'associations' do
+    it { is_expected.to have_many(:users).dependent(:destroy) }
+    it { is_expected.to have_many(:players).dependent(:destroy) }
+    it { is_expected.to have_many(:matches).dependent(:destroy) }
+    it { is_expected.to have_many(:scrims).dependent(:destroy) }
+    it { is_expected.to have_many(:competitive_matches).dependent(:destroy) }
+    it { is_expected.to have_many(:messages).dependent(:destroy) }
+  end
+
+  describe 'slug generation' do
+    it 'generates a slug from name on create' do
+      org = create(:organization, name: 'Test Team Alpha')
+      expect(org.slug).to be_present
+    end
+
+    it 'does not override a manually set slug' do
+      org = create(:organization, name: 'My Org', slug: 'custom-slug')
+      expect(org.slug).to eq('custom-slug')
+    end
+
+    it 'generates a unique slug with counter when collision exists' do
+      create(:organization, name: 'Same Name', slug: 'same-name')
+      org2 = create(:organization, name: 'Same Name')
+      expect(org2.slug).to match(/same-name-\d+/)
+    end
+  end
+
+  describe 'trial management' do
+    let(:org) { create(:organization) }
+
+    it 'sets trial period for new organizations' do
+      expect(org.subscription_status).to eq('trial')
+      expect(org.trial_expires_at).to be_present
+    end
+
+    describe '#on_trial?' do
+      it 'returns true when trial is active' do
+        expect(org.on_trial?).to be(true)
+      end
+
+      it 'returns false when trial has expired' do
+        org.update_columns(trial_expires_at: 1.day.ago)
+        expect(org.on_trial?).to be(false)
+      end
+    end
+
+    describe '#trial_expired?' do
+      it 'returns false for active trial' do
+        expect(org.trial_expired?).to be(false)
+      end
+
+      it 'returns true when trial has expired' do
+        org.update_columns(trial_expires_at: 1.day.ago)
+        expect(org.trial_expired?).to be(true)
+      end
+    end
+
+    describe '#trial_days_remaining' do
+      it 'returns a positive integer for active trials' do
+        expect(org.trial_days_remaining).to be > 0
+      end
+
+      it 'returns 0 when not on trial' do
+        org.update_columns(subscription_status: 'active')
+        expect(org.trial_days_remaining).to eq(0)
+      end
+    end
+
+    describe '#has_active_access?' do
+      it 'returns true when on active trial' do
+        expect(org.has_active_access?).to be(true)
+      end
+
+      it 'returns true with active subscription' do
+        org.update_columns(subscription_status: 'active')
+        expect(org.has_active_access?).to be(true)
+      end
+
+      it 'returns false when subscription has expired' do
+        org.update_columns(subscription_status: 'expired')
+        expect(org.has_active_access?).to be(false)
+      end
+    end
+  end
+end

spec/models/user_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe User, type: :model do
+  subject { build(:user) }
+
+  describe 'validations' do
+    it { is_expected.to validate_presence_of(:email) }
+    it { is_expected.to validate_presence_of(:full_name) }
+    it { is_expected.to validate_presence_of(:role) }
+    it { is_expected.to validate_inclusion_of(:role).in_array(Constants::User::ROLES) }
+    it { is_expected.to validate_uniqueness_of(:email).case_insensitive }
+
+    it 'rejects invalid email format' do
+      user = build(:user, email: 'not-an-email')
+      expect(user).not_to be_valid
+      expect(user.errors[:email]).to be_present
+    end
+
+    it 'accepts valid email format' do
+      user = build(:user, email: 'valid@example.com')
+      expect(user).to be_valid
+    end
+
+    it 'requires password to contain uppercase letter' do
+      user = build(:user, password: 'alllowercase1', password_confirmation: 'alllowercase1')
+      expect(user).not_to be_valid
+    end
+
+    it 'accepts a strong password' do
+      user = build(:user, password: 'StrongPass1!', password_confirmation: 'StrongPass1!')
+      expect(user).to be_valid
+    end
+
+    it 'requires minimum password length of 8' do
+      user = build(:user, password: 'Ab1', password_confirmation: 'Ab1')
+      expect(user).not_to be_valid
+    end
+  end
+
+  describe 'associations' do
+    it { is_expected.to belong_to(:organization) }
+    it { is_expected.to have_many(:notifications).dependent(:destroy) }
+    it { is_expected.to have_many(:audit_logs).dependent(:destroy) }
+    it { is_expected.to have_many(:password_reset_tokens).dependent(:destroy) }
+  end
+
+  describe 'scopes' do
+    let!(:organization) { create(:organization) }
+    let!(:active_user)  { create(:user, organization: organization, last_login_at: 1.hour.ago) }
+    let!(:never_logged) { create(:user, organization: organization, last_login_at: nil) }
+
+    describe '.by_role' do
+      it 'filters users by role' do
+        owner = create(:user, :owner, organization: organization)
+        expect(User.by_role('owner')).to include(owner)
+        expect(User.by_role('owner')).not_to include(active_user)
+      end
+    end
+
+    describe '.active' do
+      it 'includes users who have logged in' do
+        expect(User.active).to include(active_user)
+      end
+
+      it 'excludes users who never logged in' do
+        expect(User.active).not_to include(never_logged)
+      end
+    end
+  end
+
+  describe 'callbacks' do
+    it 'downcases email before save' do
+      user = create(:user, email: 'UPPER@EXAMPLE.COM')
+      expect(user.reload.email).to eq('upper@example.com')
+    end
+  end
+
+  describe '#admin?' do
+    it 'returns true for admin role' do
+      expect(build(:user, :admin).admin?).to be(true)
+    end
+
+    it 'returns false for coach role' do
+      expect(build(:user, :coach).admin?).to be(false)
+    end
+  end
+
+  describe '#owner?' do
+    it 'returns true for owner role' do
+      expect(build(:user, :owner).owner?).to be(true)
+    end
+
+    it 'returns false for admin role' do
+      expect(build(:user, :admin).owner?).to be(false)
+    end
+  end
+
+  describe '#can_manage_players?' do
+    it 'returns true for owner, admin, and coach' do
+      %w[owner admin coach].each do |role|
+        expect(build(:user, role: role).can_manage_players?).to be(true),
+          "expected #{role} to manage players"
+      end
+    end
+
+    it 'returns false for analyst and viewer' do
+      %w[analyst viewer].each do |role|
+        expect(build(:user, role: role).can_manage_players?).to be(false),
+          "expected #{role} not to manage players"
+      end
+    end
+  end
+
+  describe '#can_view_analytics?' do
+    it 'returns true for owner, admin, coach, and analyst' do
+      %w[owner admin coach analyst].each do |role|
+        expect(build(:user, role: role).can_view_analytics?).to be(true)
+      end
+    end
+
+    it 'returns false for viewer' do
+      expect(build(:user, :viewer).can_view_analytics?).to be(false)
+    end
+  end
+
+  describe '#update_last_login!' do
+    it 'sets last_login_at to the current time' do
+      user = create(:user)
+      expect { user.update_last_login! }.to change { user.reload.last_login_at }.from(nil)
+    end
+  end
+end