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

require 'rails_helper'

RSpec.describe Selector::Base, searchindex: true do
  let(:default_organization) { create(:organization) }
  let(:agent)                { create(:agent, groups: [Group.first]) }
  let(:agent_owner)          { create(:agent, groups: [Group.first], organization: default_organization) }
  let(:default_customer)     { create(:customer, organization: default_organization) }
  let(:ticket_1)             { create(:ticket, title: 'bli', group: Group.first, owner: agent_owner, customer: default_customer) }
  let(:ticket_2)             { create(:ticket, title: 'bla', group: Group.first, owner: agent_owner, customer: default_customer) }
  let(:ticket_3)             { create(:ticket, title: 'blub', group: Group.first, owner: agent_owner, customer: default_customer) }

  before do
    Ticket.destroy_all
    ticket_1 && ticket_2 && ticket_3
    searchindex_model_reload([Ticket])
  end

  it 'does support AND conditions', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'b',
        },
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'l',
        },
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'b',
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(3)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(3)
  end

  it 'does support NOT conditions', :aggregate_failures do
    condition = {
      operator:   'NOT',
      conditions: [
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'b',
        },
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'l',
        },
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'b',
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(0)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(0)
  end

  it 'does support OR conditions', :aggregate_failures do
    condition = {
      operator:   'OR',
      conditions: [
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'bli',
        },
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'bla',
        },
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'blub',
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(3)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(3)
  end

  it 'does support OR conditions (one missing)', :aggregate_failures do
    condition = {
      operator:   'OR',
      conditions: [
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'xxx',
        },
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'bla',
        },
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'blub',
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(2)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(2)
  end

  it 'does support OR conditions (all missing)', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'bli',
        },
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'bla',
        },
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'blub',
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(0)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(0)
  end

  it 'does support sub level conditions', :aggregate_failures do
    condition = {
      operator:   'OR',
      conditions: [
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'bli',
        },
        {
          operator:   'OR',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    'bla',
            },
            {
              name:     'ticket.title',
              operator: 'is',
              value:    'blub',
            },
          ],
        }
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(3)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(3)
  end

  it 'does support sub level conditions (one missing)', :aggregate_failures do
    condition = {
      operator:   'OR',
      conditions: [
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'bli',
        },
        {
          operator:   'OR',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    'xxx',
            },
            {
              name:     'ticket.title',
              operator: 'is',
              value:    'blub',
            },
          ],
        }
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(2)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(2)
  end

  it 'does support sub level conditions (all missing)', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          name:     'ticket.title',
          operator: 'is',
          value:    'bli',
        },
        {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    'bla',
            },
            {
              name:     'ticket.title',
              operator: 'is',
              value:    'blub',
            },
          ],
        }
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(0)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(0)
  end

  it 'does return all 3 results on empty condition', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: []
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(3)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(3)
  end

  it 'does return all 3 results on empty sub condition', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'b',
        },
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'l',
        },
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'b',
        },
        {
          operator:   'AND',
          conditions: [
          ],
        }
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(3)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(3)
  end

  it 'does return all 3 results on empty sub sub condition', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'b',
        },
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'l',
        },
        {
          name:     'ticket.title',
          operator: 'contains',
          value:    'b',
        },
        {
          operator:   'AND',
          conditions: [
            {
              operator:   'AND',
              conditions: [
              ],
            }
          ],
        }
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(3)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(3)
  end

  it 'does support owner_id is not_set pre_condition', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          pre_condition: 'not_set',
          name:          'ticket.owner_id',
          operator:      'is',
          value:         [],
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(0)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(0)
  end

  it 'does support owner_id is not not_set pre_condition', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          pre_condition: 'not_set',
          name:          'ticket.owner_id',
          operator:      'is not',
          value:         [],
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(3)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(3)
  end

  it 'does support owner is current_user.id pre_condition', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          pre_condition: 'current_user.id',
          name:          'ticket.owner_id',
          operator:      'is',
          value:         [],
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent_owner })
    expect(count).to eq(3)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent_owner })
    expect(result[:count]).to eq(3)
  end

  it 'does support owner is current_user.id pre_condition but user has none', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          pre_condition: 'current_user.id',
          name:          'ticket.owner_id',
          operator:      'is',
          value:         [],
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(0)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(0)
  end

  it 'does support owner is current_user.organization_id pre_condition', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          pre_condition: 'current_user.organization_id',
          name:          'ticket.organization_id',
          operator:      'is',
          value:         [],
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent_owner })
    expect(count).to eq(3)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent_owner })
    expect(result[:count]).to eq(3)
  end

  it 'does support owner is current_user.organization_id pre_condition but user has none', :aggregate_failures do
    condition = {
      operator:   'AND',
      conditions: [
        {
          pre_condition: 'current_user.organization_id',
          name:          'ticket.organization_id',
          operator:      'is',
          value:         [],
        },
      ]
    }

    count, = Ticket.selectors(condition, { current_user: agent })
    expect(count).to eq(0)

    result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
    expect(result[:count]).to eq(0)
  end

  describe 'Datetime operators' do
    let(:created_at) { 1.day.ago.iso8601 }

    before do
      ticket_1.update(created_at:)
      searchindex_model_reload([Ticket])
    end

    it 'does support today operator (#4901)', :aggregate_failures do
      condition = {
        operator:   'AND',
        conditions: [
          {
            name:     'ticket.created_at',
            operator: 'today',
          },
        ]
      }

      count, = Ticket.selectors(condition, { current_user: agent })
      expect(count).to eq(2)

      result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
      expect(result[:count]).to eq(2)
    end

    describe 'when in range' do
      it 'does match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket_1.title,
            },
            {
              name:     'ticket.created_at',
              operator: 'in range',
              value:    [created_at, created_at],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'does not match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket_1.title,
            },
            {
              name:     'ticket.created_at',
              operator: 'in range',
              value:    ['', 2.days.ago.iso8601],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end
  end

  describe 'Overview condition Date field = TODAY calculated incorrectly #6464', db_strategy: :reset do
    let(:field_name) { SecureRandom.hex(8) }
    let(:title)      { SecureRandom.uuid }

    def condition_for(name, operator, range: nil)
      {
        operator:   'AND',
        conditions: [
          {
            name:     'ticket.title',
            operator: 'is',
            value:    title,
          },
          {
            name:     name,
            operator: operator,
            range:    range,
            value:    range && '1',
          }.compact,
        ]
      }
    end

    before do
      Setting.set('timezone_default', timezone)
      travel_to Time.find_zone(timezone).parse(local_time)
      create(:object_manager_attribute_date, object_name: 'Ticket', name: field_name)
      ObjectManager::Attribute.migration_execute
      tickets
      searchindex_model_reload([Ticket])
    end

    shared_examples 'matching the same tickets' do |operator, expected, range: nil|
      it "matches the tickets #{expected} with '#{operator}'", :aggregate_failures do
        condition = condition_for(condition_name, operator, range:)

        _, result = Ticket.selectors(condition, { current_user: agent })
        expect(result).to match_array(tickets.values_at(*expected))

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:object_ids]).to match_array(tickets.values_at(*expected).map { it.id.to_s })
      end
    end

    context 'with a date field' do
      let(:condition_name) { "ticket.#{field_name}" }
      let(:today)          { Date.parse(local_time) }
      let(:offsets)        { -2..2 }
      let(:tickets) do
        offsets.index_with do |offset|
          create(:ticket, title:, group: Group.first, owner: agent_owner, customer: default_customer, field_name => today + offset)
        end
      end

      shared_examples 'comparing against dates in the system timezone' do
        include_examples 'matching the same tickets', 'today', [0]
        include_examples 'matching the same tickets', 'within last (relative)', [-1, 0], range: 'day'
        include_examples 'matching the same tickets', 'within next (relative)', [0, 1], range: 'day'
        include_examples 'matching the same tickets', 'before (relative)', [-2, -1], range: 'day'
        include_examples 'matching the same tickets', 'after (relative)', [1, 2], range: 'day'
        include_examples 'matching the same tickets', 'till (relative)', [-2, -1, 0, 1], range: 'day'
        include_examples 'matching the same tickets', 'from (relative)', [-1, 0, 1, 2], range: 'day'
      end

      context 'with a timezone behind UTC, late in the evening' do
        let(:timezone)   { 'America/Chicago' }
        let(:local_time) { '2026-10-16 23:30' }

        include_examples 'comparing against dates in the system timezone'
      end

      context 'with a timezone ahead of UTC, shortly after midnight' do
        let(:timezone)   { 'Europe/Berlin' }
        let(:local_time) { '2026-10-16 00:30' }

        include_examples 'comparing against dates in the system timezone'
      end

      context 'with a timezone ahead of UTC, shortly after midnight on the day after a DST change' do
        let(:timezone)   { 'Europe/Berlin' }
        let(:local_time) { '2026-03-30 00:30' }

        include_examples 'comparing against dates in the system timezone'
      end

      context 'with a timezone ahead of UTC, shortly after midnight on the first day of a month' do
        let(:timezone)   { 'Europe/Berlin' }
        let(:local_time) { '2026-05-01 00:30' }
        let(:offsets)    { [-31, -30, -29] }

        include_examples 'matching the same tickets', 'before (relative)', [-31, -30], range: 'month'
      end
    end

    # Shortly after midnight in Berlin, the UTC date is still yesterday.
    context 'with a datetime field' do
      let(:timezone)       { 'Europe/Berlin' }
      let(:local_time)     { '2026-10-16 00:30' }
      let(:condition_name) { 'ticket.created_at' }
      let(:tickets) do
        { yesterday: 1.hour.ago, today: Time.zone.now }.transform_values do |created_at|
          create(:ticket, title:, group: Group.first, owner: agent_owner, customer: default_customer, created_at:)
        end
      end

      include_examples 'matching the same tickets', 'today', [:today]
    end
  end

  describe 'Selector "contains" on relation fields (e.g. customer.email) no longer matches values containing "@" #6232' do
    let(:customer) { create(:customer, email: 'john.doe@example.com') }
    let(:ticket)   { create(:ticket, title: 'bli', group: Group.first, customer: customer) }

    before do
      Ticket.destroy_all
      ticket
      searchindex_model_reload([Ticket])
    end

    it 'matches a relation string field by a value containing "@" (wildcard on the .keyword subfield)', :aggregate_failures do
      condition = {
        operator:   'AND',
        conditions: [
          {
            name:     'customer.email',
            operator: 'contains',
            value:    'john.doe@example.com',
          },
        ],
      }

      count, = Ticket.selectors(condition, { current_user: agent })
      expect(count).to eq(1)

      result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
      expect(result[:count]).to eq(1)
    end
  end

  describe 'Trigger do not allow "Multi-Tree-Select" Fields on Organization and User Level as If Condition #4504', db_strategy: :reset do
    let(:field_name)   { SecureRandom.uuid }
    let(:organization) { create(:organization, field_name => ['Incident', 'Incident::Hardware']) }
    let(:customer)     { create(:customer, organization: organization, field_name => ['Incident', 'Incident::Hardware']) }
    let(:ticket)       { create(:ticket, title: 'bli', group: Group.first, customer: customer, field_name => ['Incident', 'Incident::Hardware']) }

    def check_condition(attribute)
      condition = {
        operator:   'AND',
        conditions: [
          {
            name:     attribute.to_s,
            operator: 'contains all',
            value:    ['Incident', 'Incident::Hardware'],
          }
        ]
      }

      count, = Ticket.selectors(condition, { current_user: agent })
      expect(count).to eq(1)

      count, = Ticket.selectors(condition, { current_user: agent })
      expect(count).to eq(1)
    end

    before do
      create(:object_manager_attribute_multi_tree_select, object_name: 'Ticket', name: field_name)
      create(:object_manager_attribute_multi_tree_select, object_name: 'User', name: field_name)
      create(:object_manager_attribute_multi_tree_select, object_name: 'Organization', name: field_name)
      ObjectManager::Attribute.migration_execute
      ticket
      searchindex_model_reload([Ticket, User, Organization])
    end

    it 'does support contains one for all objects' do # rubocop:disable RSpec/NoExpectationExample
      check_condition("ticket.#{field_name}")
      check_condition("customer.#{field_name}")
      check_condition("organization.#{field_name}")
    end
  end

  describe 'Reporting profiles do not work with multi tree select #4546' do
    context 'when value is a string' do
      before do
        create(:tag, tag_item: create(:'tag/item', name: 'AAA'), o: ticket_1)
        create(:tag, tag_item: create(:'tag/item', name: 'BBB'), o: ticket_1)
        searchindex_model_reload([Ticket])
      end

      it 'does return ticket by contains all string value', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all',
              value:    'AAA, BBB',
            }
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end
    end

    context 'when value is an array', db_strategy: :reset do
      let(:field_name) { SecureRandom.uuid }

      before do
        create(:object_manager_attribute_multi_tree_select, name: field_name)
        ObjectManager::Attribute.migration_execute
        ticket_1.reload.update(field_name => ['Incident', 'Incident::Hardware'])
        searchindex_model_reload([Ticket])
      end

      it 'does return ticket by contains all array value', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     "ticket.#{field_name}",
              operator: 'contains all',
              value:    ['Incident', 'Incident::Hardware'],
            }
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end
    end
  end

  describe 'Report profiles: Problem with some conditions (starts with, ends with, is any, is none) #4798' do
    context 'when operator is any of' do
      it 'does match', :aggregate_failures do
        condition = {
          operator:   'OR',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is any of',
              value:    %w[bli bla],
            },
            {
              name:     'ticket.title',
              operator: 'is any of',
              value:    ['blub'],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(3)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(3)
      end

      it 'does not match', :aggregate_failures do
        condition = {
          operator:   'OR',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is any of',
              value:    %w[blix blax],
            },
            {
              name:     'ticket.title',
              operator: 'is any of',
              value:    ['blubx'],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end

    context 'when operator is none of' do
      it 'does match', :aggregate_failures do
        condition = {
          operator:   'OR',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is none of',
              value:    %w[blix blax],
            },
            {
              name:     'ticket.title',
              operator: 'is none of',
              value:    ['blubx'],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(3)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(3)
      end

      it 'does not match', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is none of',
              value:    %w[bli bla],
            },
            {
              name:     'ticket.title',
              operator: 'is none of',
              value:    ['blub'],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end

    context 'when operator starts with one of' do
      it 'does match', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'starts with one of',
              value:    ['bl'],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(3)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(3)
      end

      it 'does not match', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'starts with one of',
              value:    ['aaa'],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end

    context 'when operator ends with one of' do
      it 'does match', :aggregate_failures do
        condition = {
          operator:   'OR',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'ends with one of',
              value:    %w[li la],
            },
            {
              name:     'ticket.title',
              operator: 'ends with one of',
              value:    ['ub'],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(3)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(3)
      end

      it 'does not match', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'ends with one of',
              value:    ['ubx'],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end
  end

  describe 'Text input operators', db_strategy: :reset do
    let(:field_name) { SecureRandom.hex(8) }
    let(:ticket)     { create(:ticket, title: SecureRandom.uuid, group: Group.first, owner: agent_owner, customer: default_customer, field_name => 'foobar') }

    before do
      create(:object_manager_attribute_text, object_name: 'Ticket', name: field_name)
      ObjectManager::Attribute.migration_execute
      ticket
      searchindex_model_reload([Ticket])
    end

    describe 'when matches' do
      it 'does match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'matches',
              value:    'foo*',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'does not match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'matches',
              value:    'bar*',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end
  end

  describe 'Tags' do
    let(:ta) { create(:'tag/item', name: 'a') }
    let(:tb) { create(:'tag/item', name: 'b') }
    let(:tc) { create(:'tag/item', name: 'c') }
    let(:td) { create(:'tag/item', name: 'd') }

    let(:ticket_a) do
      create(:ticket, group: Group.first).tap do |ticket|
        create(:tag, o: ticket, tag_item: ta)
      end
    end
    let(:ticket_a_b) do
      create(:ticket, group: Group.first).tap do |ticket|
        create(:tag, o: ticket, tag_item: ta)
        create(:tag, o: ticket, tag_item: tb)
      end
    end
    let(:ticket_none) { create(:ticket, group: Group.first) }

    before do
      Ticket.destroy_all
      ta && tb && tc && td
      ticket_a && ticket_a_b && ticket_none
      searchindex_model_reload([Ticket])
    end

    describe 'contains all' do
      it 'checks tags a = 2', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all',
              value:    'a',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(2)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(2)
      end

      it 'checks tags a, b = 1', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all',
              value:    'a,b',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'checks tags a, c = 0', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all',
              value:    'a,c',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end

      it 'checks tags a, b, c = 0', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all',
              value:    'a,b,c',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end

      it 'checks tags c, d = 0', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all',
              value:    'c,d',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end

      it 'checks tags d = 0', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all',
              value:    'd',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end

    describe 'contains one' do
      it 'checks tags a = 2', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one',
              value:    'a',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(2)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(2)
      end

      it 'checks tags a, b = 2', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one',
              value:    'a,b',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(2)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(2)
      end

      it 'checks tags a, c = 2', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one',
              value:    'a,c',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(2)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(2)
      end

      it 'checks tags a, b, c = 2', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one',
              value:    'a,b,c',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(2)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(2)
      end

      it 'checks tags c, d = 0', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one',
              value:    'c,d',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end

      it 'checks tags d = 0', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one',
              value:    'd',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end

    describe 'contains all not' do
      it 'checks tags a = 1', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all not',
              value:    'a',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'checks tags a, b = 2', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all not',
              value:    'a,b',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(2)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(2)
      end

      it 'checks tags a, c = 3', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all not',
              value:    'a,c',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(3)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(3)
      end

      it 'checks tags a, b, c = 3', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all not',
              value:    'a,b,c',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(3)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(3)
      end

      it 'checks tags c, d = 3', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all not',
              value:    'c,d',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(3)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(3)
      end

      it 'checks tags d = 3', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains all not',
              value:    'd',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(3)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(3)
      end
    end

    describe 'contains one not' do
      it 'checks tags a = 1', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one not',
              value:    'a',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'checks tags a, b = 1', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one not',
              value:    'a,b',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'checks tags a, c = 1', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one not',
              value:    'a,c',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'checks tags a, b, c = 1', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one not',
              value:    'a,b,c',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'checks tags c, d = 3', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one not',
              value:    'c,d',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(3)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(3)
      end

      it 'checks tags d = 3', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.tags',
              operator: 'contains one not',
              value:    'd',
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(3)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(3)
      end
    end
  end

  describe 'Integer operators', db_strategy: :reset do
    let(:field_name) { SecureRandom.hex(8) }
    let(:ticket)     { create(:ticket, title: SecureRandom.uuid, group: Group.first, owner: agent_owner, customer: default_customer, field_name => 42) }

    before do
      create(:object_manager_attribute_integer, object_name: 'Ticket', name: field_name)
      ObjectManager::Attribute.migration_execute
      ticket
      searchindex_model_reload([Ticket])
    end

    describe 'when is less than' do
      it 'does match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'is less than',
              value:    43,
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'does not match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'is less than',
              value:    42,
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end

    describe 'when is less than or equal to' do
      it 'does match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'is less than or equal to',
              value:    42,
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'does not match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'is less than or equal to',
              value:    41,
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end

    describe 'when is greater than' do
      it 'does match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'is greater than',
              value:    41,
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'does not match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'is greater than',
              value:    42,
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end

    describe 'when is greater than or equal to' do
      it 'does match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'is greater than or equal to',
              value:    42,
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'does not match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'is greater than or equal to',
              value:    43,
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end

    describe 'when in range' do
      it 'does match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'in range',
              value:    [42, 42],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(1)
      end

      it 'does not match the ticket', :aggregate_failures do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'ticket.title',
              operator: 'is',
              value:    ticket.title,
            },
            {
              name:     "ticket.#{field_name}",
              operator: 'in range',
              value:    ['', '41'],
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(0)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(0)
      end
    end
  end

  describe 'Report Profile with selector "starts with one of" on text objects results in "unknown operator" #5198' do
    before do
      ticket_1.update(title: "1111 #{ticket_1.title}")
      ticket_2.update(title: "1111 #{ticket_2.title}")
      ticket_3.update(title: "1111 #{ticket_3.title}")
      searchindex_model_reload([Ticket])
    end

    it 'does match', :aggregate_failures do
      condition = {
        operator:   'AND',
        conditions: [
          {
            name:     'ticket.title',
            operator: 'starts with one of',
            value:    ['111'],
          },
        ]
      }

      count, = Ticket.selectors(condition, { current_user: agent })
      expect(count).to eq(3)

      result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
      expect(result[:count]).to eq(3)
    end
  end

  # https://github.com/zammad/zammad/issues/5623
  describe 'selectors relying on .keyword suffix fails with long articles', :aggregate_failures do
    let(:term)        { 'ežiukas' }
    let(:short_text) { "#{Faker::Lorem.characters(number: 30)} #{term}" }
    let(:long_text)  { "#{term} #{Faker::Lorem.characters(number: 300)}" }

    context 'when item is Ticket' do
      let(:article_short) { create(:ticket_article, ticket: ticket_1, body: short_text) }
      let(:article_long)  { create(:ticket_article, ticket: ticket_2, body: long_text) }

      before do
        article_short && article_long
        searchindex_model_reload([Ticket])
      end

      it 'article body does match' do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'article.body',
              operator: 'contains',
              value:    term,
            },
          ]
        }

        count, = Ticket.selectors(condition, { current_user: agent })
        expect(count).to eq(2)

        result = SearchIndexBackend.selectors('Ticket', condition, { current_user: agent })
        expect(result[:count]).to eq(2)
      end
    end

    context 'when item is Organization' do
      let(:organization_short) { create(:organization, note: short_text) }
      let(:organization_long)  { create(:organization, note: long_text) }

      before do
        organization_short && organization_long
        searchindex_model_reload([Organization])
      end

      it 'organization note does match' do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'organization.note',
              operator: 'contains',
              value:    term,
            },
          ]
        }

        count, = Organization.selectors(condition, { current_user: agent })
        expect(count).to eq(2)

        result = SearchIndexBackend.selectors('Organization', condition, { current_user: agent })
        expect(result[:count]).to eq(2)
      end
    end

    context 'when item is KB Answer' do
      let(:answer_short) { create(:knowledge_base_answer_translation_content, body: short_text).translation.answer }
      let(:answer_long) { create(:knowledge_base_answer_translation_content, body: long_text).translation.answer }

      before do
        answer_short && answer_long
        searchindex_model_reload([KnowledgeBase::Answer::Translation])
      end

      it 'answer content does match' do
        condition = {
          operator:   'AND',
          conditions: [
            {
              name:     'content.body',
              operator: 'contains',
              value:    term,
            },
          ]
        }

        count, = KnowledgeBase::Answer::Translation.selectors(condition, { current_user: agent })
        expect(count).to eq(2)

        result = SearchIndexBackend.selectors('KnowledgeBase::Answer::Translation', condition, { current_user: agent })
        expect(result[:count]).to eq(2)
      end
    end
  end

  # https://github.com/zammad/zammad/issues/5686
  describe 'text blob selectors fail with complex partial phrases', :aggregate_failures do
    let(:ticket)    { create(:ticket, title: 'This is a test ticket') }
    let(:article)   { create(:ticket_article, ticket: ticket, body: 'phrase: 1337') }
    let(:condition) do
      {
        operator:   'AND',
        conditions: [
          {
            name:     'article.body',
            operator: 'contains',
            value:    term,
          },
        ]
      }
    end

    before do
      article
      searchindex_model_reload([Ticket])
    end

    context 'when term is a full phrase' do
      let(:term) { 'phrase: 1337' }

      it 'does match' do
        count, = Ticket.selectors(condition)
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition)
        expect(result[:count]).to eq(1)
      end
    end

    context 'when term is a partial phrase' do
      let(:term) { 'phrase: 13' }

      it 'does match' do
        count, = Ticket.selectors(condition)
        expect(count).to eq(1)

        result = SearchIndexBackend.selectors('Ticket', condition)
        expect(result[:count]).to eq(1)
      end
    end
  end

  describe 'Wildcard keyword search is case sensitive #6125', :aggregate_failures do
    let(:ticket) { create(:ticket, title: 'This is a Test Ticket') }

    before do
      ticket
      searchindex_model_reload([Ticket])
    end

    it 'matches in case-insensitive manner' do
      condition = {
        operator:   'AND',
        conditions: [
          {
            name:     'ticket.title',
            operator: 'contains',
            value:    'test',
          },
        ]
      }

      count, = Ticket.selectors(condition)
      expect(count).to eq(1)

      result = SearchIndexBackend.selectors('Ticket', condition)
      expect(result[:count]).to eq(1)
    end
  end
end
