discourse-chat-integration/spec/models/rule_spec.rb

# frozen_string_literal: true

require 'rails_helper'
require_relative '../dummy_provider'

RSpec.describe DiscourseChatIntegration::Rule do
  include_context "with dummy provider"

  let(:tag1) { Fabricate(:tag) }
  let(:tag2) { Fabricate(:tag) }

  let(:channel) { DiscourseChatIntegration::Channel.create(provider: 'dummy') }
  let(:category) { Fabricate(:category) }
  let(:group) { Fabricate(:group) }

  describe '.alloc_key' do
    it 'should return sequential numbers' do
      expect(DiscourseChatIntegration::Rule.create(channel: channel).key).to eq("rule:1")
      expect(DiscourseChatIntegration::Rule.create(channel: channel).key).to eq("rule:2")
      expect(DiscourseChatIntegration::Rule.create(channel: channel).key).to eq("rule:3")
    end
  end

  it 'should convert between channel and channel_id successfully' do
    rule = DiscourseChatIntegration::Rule.create(channel: channel)
    expect(rule.channel_id).to eq(channel.id)
    expect(rule.channel.id).to eq(channel.id)
  end

  it 'should save and load successfully' do
    expect(DiscourseChatIntegration::Rule.all.length).to eq(0)

    rule = DiscourseChatIntegration::Rule.create(channel: channel,
                                                 category_id: category.id,
                                                 tags: [tag1.name, tag2.name],
                                                 filter: 'watch')

    expect(DiscourseChatIntegration::Rule.all.length).to eq(1)

    loadedRule = DiscourseChatIntegration::Rule.find(rule.id)

    expect(loadedRule.channel.id).to eq(channel.id)
    expect(loadedRule.category_id).to eq(category.id)
    expect(loadedRule.tags).to contain_exactly(tag1.name, tag2.name)
    expect(loadedRule.filter).to eq('watch')

  end

  describe 'general operations' do
    before do
      rule = DiscourseChatIntegration::Rule.create(channel: channel,
                                                   category_id: category.id,
                                                   tags: [tag1.name, tag2.name])
    end

    it 'can be modified' do
      rule = DiscourseChatIntegration::Rule.all.first
      rule.tags = [tag1.name]

      rule.save!

      rule = DiscourseChatIntegration::Rule.all.first
      expect(rule.tags).to contain_exactly(tag1.name)
    end

    it 'can be deleted' do
      DiscourseChatIntegration::Rule.new(channel: channel).save!
      expect(DiscourseChatIntegration::Rule.all.length).to eq(2)

      rule = DiscourseChatIntegration::Rule.all.first
      rule.destroy

      expect(DiscourseChatIntegration::Rule.all.length).to eq(1)
    end

    it 'can delete all' do
      DiscourseChatIntegration::Rule.create(channel: channel)
      DiscourseChatIntegration::Rule.create(channel: channel)
      DiscourseChatIntegration::Rule.create(channel: channel)
      DiscourseChatIntegration::Rule.create(channel: channel)

      expect(DiscourseChatIntegration::Rule.all.length).to eq(5)

      DiscourseChatIntegration::Rule.destroy_all

      expect(DiscourseChatIntegration::Rule.all.length).to eq(0)
    end

    it 'can be filtered by channel' do
      channel2 = DiscourseChatIntegration::Channel.create(provider: 'dummy')
      channel3 = DiscourseChatIntegration::Channel.create(provider: 'dummy')

      rule2 = DiscourseChatIntegration::Rule.create(channel: channel)
      rule3 = DiscourseChatIntegration::Rule.create(channel: channel)
      rule4 = DiscourseChatIntegration::Rule.create(channel: channel2)
      rule5 = DiscourseChatIntegration::Rule.create(channel: channel3)

      expect(DiscourseChatIntegration::Rule.all.length).to eq(5)

      expect(DiscourseChatIntegration::Rule.with_channel(channel).length).to eq(3)
      expect(DiscourseChatIntegration::Rule.with_channel(channel2).length).to eq(1)
    end

    it 'can be filtered by category' do
      rule2 = DiscourseChatIntegration::Rule.create(channel: channel, category_id: category.id)
      rule3 = DiscourseChatIntegration::Rule.create(channel: channel, category_id: nil)

      expect(DiscourseChatIntegration::Rule.all.length).to eq(3)

      expect(DiscourseChatIntegration::Rule.with_category_id(category.id).length).to eq(2)
      expect(DiscourseChatIntegration::Rule.with_category_id(nil).length).to eq(1)
    end

    it 'can be filtered by group' do
      group1 = Fabricate(:group)
      group2 = Fabricate(:group)
      rule2 = DiscourseChatIntegration::Rule.create!(channel: channel, type: 'group_message', group_id: group1.id)
      rule3 = DiscourseChatIntegration::Rule.create!(channel: channel, type: 'group_message', group_id: group2.id)

      expect(DiscourseChatIntegration::Rule.all.length).to eq(3)

      expect(DiscourseChatIntegration::Rule.with_category_id(category.id).length).to eq(1)
      expect(DiscourseChatIntegration::Rule.with_group_ids([group1.id, group2.id]).length).to eq(2)
      expect(DiscourseChatIntegration::Rule.with_group_ids([group1.id]).length).to eq(1)
      expect(DiscourseChatIntegration::Rule.with_group_ids([group2.id]).length).to eq(1)
    end

    it 'can be filtered by type' do
      group1 = Fabricate(:group)

      rule2 = DiscourseChatIntegration::Rule.create!(channel: channel, type: 'group_message', group_id: group1.id)
      rule3 = DiscourseChatIntegration::Rule.create!(channel: channel, type: 'group_mention', group_id: group1.id)

      expect(DiscourseChatIntegration::Rule.all.length).to eq(3)

      expect(DiscourseChatIntegration::Rule.with_type('group_message').length).to eq(1)
      expect(DiscourseChatIntegration::Rule.with_type('group_mention').length).to eq(1)
      expect(DiscourseChatIntegration::Rule.with_type('normal').length).to eq(1)
    end

    it 'can be sorted by precedence' do
      rule2 = DiscourseChatIntegration::Rule.create(channel: channel, filter: 'mute')
      rule3 = DiscourseChatIntegration::Rule.create(channel: channel, filter: 'follow')
      rule4 = DiscourseChatIntegration::Rule.create(channel: channel, filter: 'thread')
      rule5 = DiscourseChatIntegration::Rule.create(channel: channel, filter: 'mute')

      expect(DiscourseChatIntegration::Rule.all.length).to eq(5)

      expect(DiscourseChatIntegration::Rule.all.order_by_precedence.map(&:filter)).to eq(["mute", "mute", "thread", "watch", "follow"])
    end
  end

  describe 'validations' do

    let(:rule) do
      DiscourseChatIntegration::Rule.create(filter: 'watch',
                                            channel: channel,
                                            category_id: category.id)
    end

    it 'validates channel correctly' do
      expect(rule.valid?).to eq(true)
      rule.channel_id = 'blahblahblah'
      expect(rule.valid?).to eq(false)
      rule.channel_id = -1
      expect(rule.valid?).to eq(false)
    end

    it "doesn't allow both category and group to be set" do
      expect(rule.valid?).to eq(true)
      rule.group_id = group.id
      expect(rule.valid?).to eq(false)
      rule.category_id = nil
      rule.type = "group_message"
      expect(rule.valid?).to eq(true)
    end

    it 'validates group correctly' do
      rule.category_id = nil
      rule.group_id = group.id
      rule.type = "group_message"
      expect(rule.valid?).to eq(true)
      rule.group_id = -99
      expect(rule.valid?).to eq(false)
    end

    it 'validates category correctly' do
      expect(rule.valid?).to eq(true)
      rule.category_id = -99
      expect(rule.valid?).to eq(false)
    end

    it 'validates filter correctly' do
      expect(rule.valid?).to eq(true)
      rule.filter = 'thread'
      expect(rule.valid?).to eq(true)
      rule.filter = 'follow'
      expect(rule.valid?).to eq(true)
      rule.filter = 'mute'
      expect(rule.valid?).to eq(true)
      rule.filter = ''
      expect(rule.valid?).to eq(false)
      rule.filter = 'somerandomstring'
      expect(rule.valid?).to eq(false)
    end

    it 'validates tags correctly' do
      expect(rule.valid?).to eq(true)
      rule.tags = []
      expect(rule.valid?).to eq(true)
      rule.tags = [tag1.name]
      expect(rule.valid?).to eq(true)
      rule.tags = [tag1.name, 'blah']
      expect(rule.valid?).to eq(false)
    end

    it "doesn't allow save when invalid" do
      expect(rule.valid?).to eq(true)
      rule.filter = 'somerandomfilter'
      expect(rule.valid?).to eq(false)
      expect(rule.save).to eq(false)
    end

  end
end