# Copyright (C) 2012-2026 Zammad Foundation, https://zammad-foundation.org/

require 'rails_helper'
require 'models/taskbar/has_attachments_examples'
require 'models/taskbar/list_examples'

RSpec.describe Taskbar, performs_jobs: true, type: :model do
  it_behaves_like 'Taskbar::HasAttachments'
  it_behaves_like 'Taskbar::List'

  context 'item' do
    subject(:taskbar) { create(:taskbar) }

    it { is_expected.to validate_inclusion_of(:app).in_array(%w[desktop mobile]) }

    it do
      expect(taskbar).to validate_uniqueness_of(:key).scoped_to(%w[user_id app]).with_message(%r{})
    end
  end

  describe '#state_changed?' do
    it 'reports no change for an empty state' do
      expect(build(:taskbar, state: {})).not_to be_state_changed
    end

    it 'looks past the form ID a tab writes whether it was touched or not' do
      expect(build(:taskbar, state: { form_id: SecureRandom.uuid })).not_to be_state_changed
    end

    # What an untouched ticket zoom tab autosaves: empty field groups, the form ID nested inside the
    #   article group, and the attachment list echoed from the upload cache.
    it 'looks past the bookkeeping of an untouched ticket zoom tab' do
      state = { ticket: {}, article: { form_id: SecureRandom.uuid, attachments: [] } }

      expect(build(:taskbar, state:)).not_to be_state_changed
    end

    # Only the empty list is bookkeeping. The ticket zoom mirrors its uploads into the same key
    #   (#taskGet), so a draft whose only content is an attached file is a draft.
    it 'reports a change for an attached file' do
      state = {
        ticket:  {},
        article: { form_id: SecureRandom.uuid, attachments: [{ 'name' => 'squares.png', 'size' => 22_198 }] },
      }

      expect(build(:taskbar, state:)).to be_state_changed
    end

    # The state of an edit screen holds only what differs from the object, so a field the user
    #   cleared arrives as an explicit nil - and clearing a value is a change like any other.
    it 'reports a change for a cleared field' do
      state = { form_id: SecureRandom.uuid, ticket: { owner_id: nil } }

      expect(build(:taskbar, state:)).to be_state_changed
    end

    it 'reports a change for a field cleared to an empty string' do
      state = { form_id: SecureRandom.uuid, title: '' }

      expect(build(:taskbar, state:)).to be_state_changed
    end

    it 'reports a change for a cleared list field' do
      state = { form_id: SecureRandom.uuid, tags: [] }

      expect(build(:taskbar, state:)).to be_state_changed
    end

    it 'reports a change for a typed value' do
      state = { form_id: SecureRandom.uuid, title: 'Typed title' }

      expect(build(:taskbar, state:)).to be_state_changed
    end

    # The mobile app brings no form state along, so its live user entry means the opposite of a
    #   form field: the value of the flag decides, not that it is stored at all.
    it 'reads the value of the live user editing flag' do
      expect(build(:taskbar, app: 'mobile', state: { editing: false })).not_to be_state_changed
      expect(build(:taskbar, app: 'mobile', state: { editing: true })).to be_state_changed
    end
  end

  describe '#preferences_task_info' do
    it 'returns task info for an existing taskbar without changes' do
      taskbar = create(:taskbar)

      expect(taskbar.preferences_task_info)
        .to eq({
                 id: taskbar.id, user_id: 1, apps: { desktop: { last_contact: taskbar.last_contact, changed: false } }
               })
    end

    it 'returns task info for an existing taskbar with changes' do
      taskbar = create(:taskbar, state: { a: 123 })

      expect(taskbar.preferences_task_info)
        .to eq({
                 id: taskbar.id, user_id: 1, apps: { desktop: { last_contact: taskbar.last_contact, changed: true } }
               })
    end

    it 'returns task info for a new taskbar' do
      taskbar = build(:taskbar)

      expect(taskbar.preferences_task_info)
        .to eq({
                 user_id: 1, apps: { desktop: { last_contact: taskbar.last_contact, changed: false } }
               })
    end

    it 'returns task info for an existing taskbar without changes (form_id only)' do
      taskbar = create(:taskbar, state: { form_id: SecureRandom.uuid })

      expect(taskbar.preferences_task_info)
        .to eq({
                 id: taskbar.id, user_id: 1, apps: { desktop: { last_contact: taskbar.last_contact, changed: false } }
               })
    end

    it 'returns task info for an existing taskbar without changes (nested form_id only)' do
      taskbar = create(:taskbar, state: { article: { form_id: SecureRandom.uuid } })

      expect(taskbar.preferences_task_info)
        .to eq({
                 id: taskbar.id, user_id: 1, apps: { desktop: { last_contact: taskbar.last_contact, changed: false } }
               })
    end
  end

  describe '#update_preferences_infos' do
    it 'do not process search taskbars' do
      taskbar = build(:taskbar, key: 'Search')

      allow(taskbar).to receive(:collect_related_tasks)
      taskbar.save
      expect(taskbar).not_to have_received(:collect_related_tasks)
    end

    it 'do not process items with local_update flag' do
      taskbar = create(:taskbar)

      allow(taskbar).to receive(:collect_related_tasks)
      taskbar.state = { a: 'b' }
      taskbar.local_update = true
      taskbar.save
      expect(taskbar).not_to have_received(:collect_related_tasks)
    end

    context 'with other taskbars' do
      let(:ticket)        { create(:ticket) }
      let(:user)          { create(:agent, groups: [ticket.group]) }
      let(:other_user)    { create(:agent, groups: [ticket.group]) }
      let(:other_taskbar) { create(:taskbar, :with_ticket, ticket:, user: other_user) }

      before { other_taskbar }

      it 'sets tasks when creating a taskbar' do
        taskbar = create(:taskbar, :with_ticket, ticket:, user:)

        expect(taskbar.preferences[:tasks]).to include(include(user_id: other_user.id), include(user_id: user.id))
      end

      it 'updates related items when creating a taskbar' do
        create(:taskbar, :with_ticket, ticket:, user:)
        perform_enqueued_jobs

        expect(other_taskbar.reload.preferences[:tasks]).to include(include(user_id: other_user.id), include(user_id: user.id))
      end

      it 'sets tasks when updating a taskbar' do
        taskbar = create(:taskbar, :with_ticket, ticket:, user:)
        taskbar.update_columns preferences: {}

        taskbar.update! state: { a: :b }

        expect(taskbar.preferences[:tasks]).to include(include(user_id: other_user.id), include(user_id: user.id))
      end

      it 'sets tasks when updating a taskbar with same user but different app' do
        taskbar = create(:taskbar, :with_ticket, ticket:, user: other_user, app: 'mobile')
        taskbar.update_columns preferences: {}

        taskbar.update! state: { a: :b }

        expect(taskbar.preferences[:tasks])
          .to include(include(user_id: other_user.id, apps: have_key(:desktop).and(have_key(:mobile))))
      end

      it 'updates related items when updating a taskbar' do
        taskbar = create(:taskbar, :with_ticket, ticket:, user:)

        other_taskbar.update_columns preferences: {}

        taskbar.update! state: { a: :b }

        perform_enqueued_jobs

        expect(other_taskbar.reload.preferences[:tasks]).to include(include(user_id: other_user.id), include(user_id: user.id))
      end

      it 'updates related items when destroying a taskbar' do
        taskbar = create(:taskbar, :with_ticket, ticket:, user:)
        taskbar.destroy!

        expect(other_taskbar.reload.preferences[:tasks]).to include(include(user_id: other_user.id))
      end
    end
  end

  describe '#collect_related_tasks' do
    let(:ticket)   { create(:ticket) }

    let(:user_1) { create(:agent, groups: [ticket.group]) }
    let(:user_2) { create(:agent, groups: [ticket.group]) }

    let(:taskbar_1) { create(:taskbar, :with_ticket, ticket:, user: user_1) }
    let(:taskbar_2) { create(:taskbar, :with_ticket, ticket:, user: user_2) }

    before { taskbar_2 }

    it 'returns tasks for self and related items' do
      expect(taskbar_1.send(:collect_related_tasks))
        .to eq([taskbar_2.preferences_task_info, taskbar_1.preferences_task_info])
    end

    it 'returns tasks for a new taskbar' do
      user = create(:agent, groups: [ticket.group])
      new_taskbar = build(:taskbar, :with_ticket, ticket:, user:)

      expect(new_taskbar.send(:collect_related_tasks))
        .to eq([taskbar_2.preferences_task_info, new_taskbar.preferences_task_info])
    end

    it 'do not include task of the destroyed taskbar' do
      taskbar_1

      taskbar_2.destroy!

      expect(taskbar_2.send(:collect_related_tasks))
        .to eq([taskbar_1.preferences_task_info])
    end

    # https://github.com/zammad/zammad/issues/5637
    it 'does not include user who does not have access to the ticket' do
      create(:taskbar, :with_ticket, ticket:)

      expect(taskbar_1.send(:collect_related_tasks))
        .to eq([taskbar_2.preferences_task_info, taskbar_1.preferences_task_info])
    end

    it 'does not leak other taskbars to user who does not have access to the ticket' do
      new_taskbar = build(:taskbar, :with_ticket, ticket:)

      expect(new_taskbar.send(:collect_related_tasks)).to be_empty
    end
  end

  describe '#reduce_related_tasks' do
    let(:elem) { { user_id: 123, changed: { desktop: false } } }
    let(:memo) { {} }

    it 'adds new task details' do
      taskbar = create(:taskbar)

      taskbar.send(:reduce_related_tasks, elem, memo)

      expect(memo).to include(elem[:user_id] => include(changed: include(desktop: false)))
    end

    it 'extends existing task details with additional apps' do
      taskbar = create(:taskbar)

      another_elem = { user_id: 123, changed: { mobile: true } }

      taskbar.send(:reduce_related_tasks, elem, memo)
      taskbar.send(:reduce_related_tasks, another_elem, memo)

      expect(memo).to include(elem[:user_id] => include(changed: include(desktop: false, mobile: true)))
    end
  end

  describe '#update_related_taskbars' do
    let(:ticket)       { create(:ticket) }
    let(:other_ticket) { create(:ticket, group: ticket.group) }
    let(:user_1)       { create(:agent, groups: [ticket.group]) }
    let(:user_2)       { create(:agent, groups: [ticket.group]) }
    let(:taskbar_1)    { create(:taskbar, :with_ticket, ticket:, user: user_1) }
    let(:taskbar_2)    { create(:taskbar, :with_ticket, ticket:, user: user_2) }
    let(:taskbar_3)    { create(:taskbar, :with_ticket, ticket: other_ticket, user: user_1) }

    before { taskbar_1 && taskbar_2 && taskbar_3 }

    it 'updates related taskbars' do
      taskbar_1.send(:update_related_taskbars)
      perform_enqueued_jobs

      expect(taskbar_2.reload.preferences[:tasks].count).to eq(2)
      expect(taskbar_3.reload.preferences[:tasks].count).to eq(1)
    end

    describe 'related taskbars job enqueuing' do
      context 'when taskbar is a ticket' do
        let(:ticket)  { create(:ticket) }
        let(:taskbar) { create(:taskbar, :with_ticket, ticket:, user:) }

        context 'when user has access to the ticket' do
          let(:user) { create(:agent, groups: [ticket.group]) }

          it 'enqueues a job to update related taskbars' do
            expect { taskbar }.to have_enqueued_job(TaskbarUpdateRelatedTasksJob)
          end
        end

        context 'when user has no access to the ticket' do
          let(:user) { create(:agent) }

          it 'enqueues a job to update related taskbars' do
            expect { taskbar }.to have_enqueued_job(TaskbarUpdateRelatedTasksJob)
          end
        end
      end

      context 'when taskbar is a user' do
        let(:taskbar) { create(:taskbar, :with_user) }

        it 'does not enqueue a job to update related taskbars' do
          expect { taskbar }.not_to have_enqueued_job(TaskbarUpdateRelatedTasksJob)
        end
      end

      context 'when taskbar is a new ticket' do
        let(:taskbar) { create(:taskbar, :with_new_ticket) }

        it 'does not enqueue a job to update related taskbars' do
          expect { taskbar }.not_to have_enqueued_job(TaskbarUpdateRelatedTasksJob)
        end
      end

      context 'when taskbar is a search' do
        let(:taskbar) { create(:taskbar, :with_search) }

        it 'does not enqueue a job to update related taskbars' do
          expect { taskbar }.not_to have_enqueued_job(TaskbarUpdateRelatedTasksJob)
        end
      end
    end
  end

  describe '#related_taskbars' do
    let(:key)       { Random.hex }
    let(:taskbar_1) { create(:taskbar, key: key, user: create(:user)) }
    let(:taskbar_2) { create(:taskbar, key: key, user: taskbar_1.user, app: 'mobile') }
    let(:taskbar_3) { create(:taskbar, key: key, user: create(:user)) }
    let(:taskbar_4) { create(:taskbar, user: create(:user)) }

    it 'calls related_taskbars scope' do
      taskbar = create(:taskbar)

      allow(described_class).to receive(:related_taskbars)

      taskbar.related_taskbars

      expect(described_class).to have_received(:related_taskbars).with(taskbar)
    end
  end

  describe '.related_taskbars' do
    let(:key)       { Random.hex }
    let(:taskbar_1) { create(:taskbar, key: key, user: create(:user)) }
    let(:taskbar_2) { create(:taskbar, key: key, user: taskbar_1.user, app: 'mobile') }
    let(:taskbar_3) { create(:taskbar, key: key, user: create(:user)) }
    let(:taskbar_4) { create(:taskbar, user: create(:user)) }

    before { taskbar_1 && taskbar_2 && taskbar_3 && taskbar_4 }

    it 'returns all taskbars with the same key except given taskbars' do
      expect(described_class.related_taskbars(taskbar_1)).to contain_exactly(taskbar_2, taskbar_3)
    end
  end

  describe '.app' do
    let(:taskbar_1) { create(:taskbar, app: 'desktop') }
    let(:taskbar_2) { create(:taskbar, app: 'mobile') }

    before { taskbar_1 && taskbar_2 }

    it 'returns given app taskbars' do
      expect(described_class.app(:desktop)).to contain_exactly(taskbar_1)
    end
  end

  describe '#saved_chanegs_to_dirty?' do
    let(:taskbar) { create(:taskbar) }

    it 'fresh taskbar has no changes to dirty' do
      expect(taskbar).not_to be_saved_change_to_dirty
    end

    it 'no changes to dirty after saving without dirty lag' do
      taskbar.active = !taskbar.active
      taskbar.save!

      expect(taskbar).not_to be_saved_change_to_dirty
    end

    it 'no changes to dirty after marking as not dirty' do
      taskbar.preferences[:dirty] = false
      taskbar.save!

      expect(taskbar).not_to be_saved_change_to_dirty
    end

    it 'dirty was changed after marking as dirty' do
      taskbar.preferences[:dirty] = true
      taskbar.save!

      expect(taskbar).to be_saved_change_to_dirty
    end

    it 'dirty was changed after marking previously dirty item as not dirty' do
      taskbar.preferences[:dirty] = true
      taskbar.save!

      taskbar.preferences[:dirty] = false
      taskbar.save!

      expect(taskbar).to be_saved_change_to_dirty
    end
  end

  describe '.to_object_ids' do
    let(:ticket)       { create(:ticket) }
    let(:ticket2)      { create(:ticket) }
    let(:organization) { create(:organization) }
    let(:user)         { create(:user) }

    let(:taskbar_ticket)       { create(:taskbar, :with_ticket, ticket:) }
    let(:taskbar_ticket2)      { create(:taskbar, :with_ticket, ticket: ticket2) }
    let(:taskbar_organization) { create(:taskbar, :with_organization, organization:) }
    let(:taskbar_user)         { create(:taskbar, :with_user, user:) }
    let(:taskbar_search)       { create(:taskbar, :with_search) }
    let(:taskbar_new_ticket)   { create(:taskbar, :with_new_ticket) }

    before do
      taskbar_ticket && taskbar_ticket2 && taskbar_organization && taskbar_user && taskbar_search && taskbar_new_ticket
    end

    it 'returns object ids' do
      expect(described_class.to_object_ids).to include(
        ticket_ids:       [ticket.id, ticket2.id],
        user_ids:         [user.id],
        organization_ids: [organization.id]
      )
    end

    it 'returns object ids in scoped relation' do
      expect(described_class.where(id: [taskbar_ticket2, taskbar_user]).to_object_ids).to include(
        ticket_ids:       [ticket2.id],
        user_ids:         [user.id],
        organization_ids: []
      )
    end
  end

  describe '#to_object' do
    context 'when a taskbar has a related object' do
      let(:ticket)  { create(:ticket) }
      let(:taskbar) { create(:taskbar, :with_ticket, ticket:) }

      it 'returns the related object' do
        expect(taskbar.to_object).to eq(ticket)
      end
    end

    context 'when a taskbar has no related object' do
      let(:taskbar) { create(:taskbar, :with_new_ticket) }

      it 'returns nil' do
        expect(taskbar.to_object).to be_nil
      end
    end
  end

  describe '#to_object_class' do
    context 'when a taskbar has a related object' do
      let(:taskbar) { create(:taskbar, :with_organization) }

      it 'returns the related object' do
        expect(taskbar.to_object_class).to eq(Organization)
      end
    end

    context 'when a taskbar has no related object' do
      let(:taskbar) { create(:taskbar, :with_new_ticket) }

      it 'returns nil' do
        expect(taskbar.to_object_class).to be_nil
      end
    end
  end

  describe '#to_object_id' do
    context 'when a taskbar has a related object' do
      let(:user)    { create(:user) }
      let(:taskbar) { create(:taskbar, :with_user, user:) }

      it 'returns the related object' do
        expect(taskbar.to_object_id).to eq(user.id)
      end
    end

    context 'when a taskbar has no related object' do
      let(:taskbar) { create(:taskbar, :with_new_ticket) }

      it 'returns nil' do
        expect(taskbar.to_object_id).to be_nil
      end
    end
  end

  describe '#relatable?' do
    context 'when it is a new ticket' do
      subject(:taskbar) { create(:taskbar, :with_new_ticket) }

      it { is_expected.not_to be_relatable }
    end

    context 'when it is a user' do
      subject(:taskbar) { create(:taskbar, :with_user) }

      it { is_expected.not_to be_relatable }
    end

    context 'when it is a detailed search' do
      subject(:taskbar) { create(:taskbar, :with_search) }

      it { is_expected.not_to be_relatable }
    end

    # Its key carries a UUID, so it does not match KEY_REGEXP at all - which has to stay
    #   harmless instead of raising.
    context 'when it is a new knowledge base answer' do
      subject(:taskbar) { create(:taskbar, :with_new_knowledge_base_answer) }

      it { is_expected.not_to be_relatable }
    end

    context 'when it is a ticket' do
      subject(:taskbar) { create(:taskbar, :with_ticket) }

      it { is_expected.to be_relatable }
    end

    # The key of an *edit* tab, which is the only one an answer's own key is used for - so the
    #   editors of one translation see each other, and a reader (who opens no tab at all) never
    #   appears among them.
    context 'when it is a knowledge base answer' do
      subject(:taskbar) { create(:taskbar, :with_knowledge_base_answer) }

      it { is_expected.to be_relatable }
    end

    # Live users are opted into per model (HasTaskbars.taskbar_live_user_pundit_method), so a model
    #   with taskbars but no list of its own must stay out - otherwise every profile tab would start
    #   collecting the other viewers into preferences nothing reads.
    context 'when it is an organization' do
      subject(:taskbar) { create(:taskbar, :with_organization) }

      it { is_expected.not_to be_relatable }
    end
  end

  describe '#target_accessible_to_owner?' do
    context 'when taskbar is a ticket' do
      subject(:taskbar) { create(:taskbar, :with_ticket, ticket:, user:) }

      context 'when owner has agent access to the ticket' do
        let(:ticket) { create(:ticket) }
        let(:user)   { create(:agent, groups: [ticket.group]) }

        it { is_expected.to be_target_accessible_to_owner }
      end

      context 'when owner has customer access to the ticket' do
        let(:ticket) { create(:ticket, customer: user) }
        let(:user) { create(:customer) }

        it { is_expected.to be_target_accessible_to_owner }
      end

      context 'when owner has no access to the ticket' do
        let(:user) { create(:user) }
        let(:ticket) { create(:ticket) }

        it { is_expected.not_to be_target_accessible_to_owner }
      end
    end

    context 'when taskbar is a user' do
      let(:taskbar) { create(:taskbar, :with_user) }

      it { expect(taskbar.target_accessible_to_owner?).to be_nil }
    end

    context 'when taskbar is a search' do
      let(:taskbar) { create(:taskbar, :with_search) }

      it { expect(taskbar.target_accessible_to_owner?).to be_nil }
    end

    context 'when taskbar is a new ticket' do
      let(:taskbar) { create(:taskbar, :with_new_ticket) }

      it { expect(taskbar.target_accessible_to_owner?).to be_nil }
    end

    context 'when taskbar is a new knowledge base answer' do
      let(:taskbar) { create(:taskbar, :with_new_knowledge_base_answer) }

      it { expect(taskbar.target_accessible_to_owner?).to be_nil }
    end

    # #update?, not #show?: a reader of the category passes the latter, and an editors' live user
    #   list is no place for somebody who cannot edit. Which also means an editor who loses access
    #   to the subtree drops out of the others' lists on the next update.
    context 'when taskbar is a knowledge base answer' do
      subject(:taskbar) { create(:taskbar, :with_knowledge_base_answer, answer:, user:) }

      let(:knowledge_base) { create(:knowledge_base) }
      let(:category)       { create(:knowledge_base_category, knowledge_base:) }

      # Internally visible, which is what makes the reader case below say something: a *draft*
      #   answer fails #show? for a reader too, so it could not tell the two queries apart.
      let(:answer) { create(:knowledge_base_answer, :internal, category:) }

      context 'when owner may edit the answer' do
        let(:user) { create(:user, roles: [create(:role, permission_names: 'knowledge_base.editor')]) }

        it { is_expected.to be_target_accessible_to_owner }
      end

      context 'when owner may only read the answer' do
        let(:user) { create(:user, roles: [create(:role, permission_names: 'knowledge_base.reader')]) }

        before do
          KnowledgeBase::PermissionsUpdate
            .new(category)
            .update! user.roles.first => 'reader'
        end

        it { is_expected.not_to be_target_accessible_to_owner }
      end

      context 'when owner lost access to the answer subtree' do
        let(:user) { create(:user, roles: [create(:role, permission_names: 'knowledge_base.editor')]) }

        before do
          KnowledgeBase::PermissionsUpdate
            .new(category)
            .update! user.roles.first => 'none'
        end

        it { is_expected.not_to be_target_accessible_to_owner }
      end

      # A tab whose answer is gone names no record, so there is nothing to authorize - and looking
      #   one up must not raise on the way to saying so.
      context 'when the answer is gone' do
        let(:user) { create(:user, roles: [create(:role, permission_names: 'knowledge_base.editor')]) }

        before do
          taskbar
          answer.destroy!
        end

        it { expect(taskbar.target_accessible_to_owner?).to be_nil }
      end
    end

    describe '#update_last_contact' do
      let(:ticket)  { create(:ticket) }
      let(:user)    { create(:agent, groups: [ticket.group]) }
      let(:taskbar) { create(:taskbar, :with_ticket, ticket:, user:) }

      before do
        freeze_time

        taskbar

        travel 1.minute
      end

      it 'sets initial contact time' do
        expect(taskbar.last_contact).to eq(1.minute.ago)
      end

      it 'updates last contact time if taskbar was updated in' do
        taskbar.state = { article: { body: 'some body' }, ticket: {} }

        expect { taskbar.save! }.to change(taskbar, :last_contact).to(Time.current)
      end

      it 'does not update last contact time if updated because of changes in a related taskbar' do
        create(:taskbar, :with_ticket, ticket:, user: create(:agent, groups: [ticket.group]))

        expect { perform_enqueued_jobs }.not_to change { taskbar.reload.last_contact }
      end

      it 'does not update last contact if taskbar was saved without any changes' do
        expect { taskbar.save! }.not_to change(taskbar, :last_contact)
      end

      it 'does not update last contact if taskbar was touched without any content changes' do
        expect { taskbar.touch }.not_to change(taskbar, :last_contact)
      end

      it 'does not update last contact if flag was the only chage' do
        taskbar.notify = true

        expect { taskbar.save! }.not_to change(taskbar, :last_contact)
      end

      it 'does not update last contact if ordering weight was the only chage' do
        taskbar.prio = 12_345

        expect { taskbar.save! }.not_to change(taskbar, :last_contact)
      end
    end
  end

  describe '#log_recent_close' do
    before do
      allow(RecentClose).to receive(:upsert_closing_time!)
    end

    context 'when taskbar has a related object' do
      let(:ticket)  { create(:ticket) }
      let(:user)    { create(:agent) }
      let(:taskbar) { create(:taskbar, :with_ticket, ticket:, user:) }

      it 'calls RecentClose.upsert_closing_time!' do
        taskbar.destroy

        expect(RecentClose).to have_received(:upsert_closing_time!).with(user, ticket)
      end
    end

    context 'when taskbar has no related object' do
      let(:user)    { create(:agent) }
      let(:taskbar) { create(:taskbar, user:) }

      it 'deos not call RecentClose.upsert_closing_time!' do
        taskbar.destroy

        expect(RecentClose).not_to have_received(:upsert_closing_time!)
      end
    end

    # #to_object_class has no branch for an answer, so recent closes stay ticket,
    #   user and organization - whether answers belong there is its own topic.
    context 'when taskbar is a knowledge base answer edit tab' do
      let(:user)    { create(:agent) }
      let(:taskbar) { create(:taskbar, :with_knowledge_base_answer, user:) }

      it 'does not call RecentClose.upsert_closing_time!', :aggregate_failures do
        expect(taskbar.to_object_class).to be_nil

        taskbar.destroy

        expect(RecentClose).not_to have_received(:upsert_closing_time!)
      end
    end
  end

  describe '.taskbar_entities' do
    it 'collects the entities of every model with taskbar support, plus the static ones' do
      expect(described_class.taskbar_entities)
        .to include('TicketZoom', 'TicketCreate', 'UserProfile', 'OrganizationProfile', 'KnowledgeBaseAnswerCreate', 'KnowledgeBaseAnswerEdit', 'Search')
    end
  end

  describe '.entity_key_prefix' do
    it 'uses the class name' do
      expect(described_class.entity_key_prefix(Ticket)).to eq('Ticket')
    end

    it 'encodes a namespaced model like the knowledge base answer' do
      expect(described_class.entity_key_prefix(KnowledgeBase::Answer)).to eq('KnowledgeBase__Answer')
    end

    it 'encodes the namespace separator like the GraphQL enums do' do
      expect(described_class.entity_key_prefix(Ticket::Article)).to eq('Ticket__Article')
    end
  end

  describe '.entity_classes' do
    # The registry is memoized, so a stubbed model list must not leak into the
    #   other examples.
    after { described_class.instance_variable_set(:@entity_classes, nil) }

    it 'contains the models with taskbar support' do
      expect(described_class.entity_classes).to include(Ticket, User, Organization, KnowledgeBase::Answer)
    end

    # Without this the entries of one model would resolve to the other one.
    #   Doubles instead of real classes, because an ApplicationModel subclass
    #   would stay in .descendants for the rest of the process.
    it 'raises for models with a colliding key prefix' do
      colliding = ['SpecAddon::Entity', 'SpecAddon__Entity'].map do |name|
        instance_double(Class, name:).tap { |model| allow(model).to receive(:include?).and_return(true) }
      end

      allow(ApplicationModel).to receive(:descendants).and_return(colliding)
      described_class.instance_variable_set(:@entity_classes, nil)

      expect { described_class.entity_classes }
        .to raise_error(%r{Taskbar key prefix 'SpecAddon__Entity' is used by SpecAddon::Entity and SpecAddon__Entity})
    end
  end

  describe '.entity_key' do
    it 'combines the key prefix and the record id' do
      ticket = create(:ticket)

      expect(described_class.entity_key(ticket)).to eq("Ticket-#{ticket.id}")
    end

    # More than one tab per record, e.g. one per locale of a knowledge base answer.
    it 'appends a qualifier' do
      answer = create(:knowledge_base_answer)

      expect(described_class.entity_key(answer, 'de-de')).to eq("KnowledgeBase__Answer-#{answer.id}-de-de")
    end
  end

  describe '.entity_key_id' do
    it 'returns the id of a record key' do
      expect(described_class.entity_key_id('Ticket-42')).to eq('42')
    end

    it 'returns the id of a namespaced record key' do
      expect(described_class.entity_key_id('KnowledgeBase__Answer-42')).to eq('42')
    end

    # The qualifier is not part of the record's identity, and must not reach a
    #   lookup - where it would survive as an integer type cast.
    it 'returns the id of a qualified record key, without the qualifier' do
      expect(described_class.entity_key_id('KnowledgeBase__Answer-42-de-de')).to eq('42')
    end

    it 'returns nil for a static entity key' do
      expect(described_class.entity_key_id('Search')).to be_nil
    end

    it 'returns nil for a create screen key' do
      expect(described_class.entity_key_id('TicketCreateScreen-a1e2c3')).to be_nil
    end
  end

  describe '.entity_pundit_method' do
    it 'authorizes with :show? by default' do
      expect(described_class.entity_pundit_method('TicketZoom')).to be(:show?)
    end

    it 'authorizes with :show? for an unknown entity' do
      expect(described_class.entity_pundit_method('SomeLegacyEntityZoom')).to be(:show?)
    end

    # A reader of the category passes KnowledgeBase::AnswerPolicy#show?, but has
    #   nothing to do with an edit tab.
    it 'authorizes the knowledge base answer edit tab with :update?' do
      expect(described_class.entity_pundit_method('KnowledgeBaseAnswerEdit')).to be(:update?)
    end
  end

  describe '#assets' do
    # Only a ticket create tab references users in its state, so it is the only
    #   one that adds assets besides its own.
    it 'adds nothing but the taskbar itself for a knowledge base answer edit tab' do
      taskbar = create(:taskbar, :with_knowledge_base_answer)

      expect(taskbar.assets({}).keys).to eq([described_class.to_app_model])
    end
  end

  describe '.entity_class_for_key_prefix' do
    it 'resolves a known prefix' do
      expect(described_class.entity_class_for_key_prefix('Ticket')).to eq(Ticket)
    end

    # Stubbing the class list (not the map) so the prefix is really encoded and
    #   decoded again - a namespaced model with taskbar support only exists in
    #   addons.
    it 'resolves an encoded namespaced prefix' do
      model = instance_double(Class, name: 'SpecAddon::Entity')
      allow(described_class).to receive(:entity_classes).and_return([model])

      expect(described_class.entity_class_for_key_prefix('SpecAddon__Entity')).to eq(model)
    end

    it 'returns nil for an unknown prefix' do
      expect(described_class.entity_class_for_key_prefix('SomeLegacyEntityZoom')).to be_nil
    end
  end
end
