require 'spec_helper'

module Calagator
  describe Event::Search, type: :model do
    let(:events) { double }
    before { allow(Event).to receive(:search).and_return(events) }
    before { allow(Event).to receive(:search_tag).and_return(events) }

    let(:search_params) { {} }
    subject(:event_search) { Event::Search.new(search_params) }

    describe 'by keyword' do
      let(:search_params) { { query: 'myquery' } }

      it 'should find all events matching the keyword, ordered by date' do
        event_search.events
        expect(Event).to have_received(:search).with('myquery', skip_old: false, order: 'date')
      end

      context 'limited to current events' do
        let(:search_params) { { query: 'myquery', current: '1' } }

        it 'should be able to only return current events' do
          event_search.events
          expect(Event).to have_received(:search).with('myquery', order: 'date', skip_old: true)
        end
      end

      context 'with an invalid order' do
        let(:search_params) { { query: 'myquery', order: 'kittens' } }

        it 'should set a failure message as a warning' do
          expect(event_search.failure_message).to eq('Unknown ordering option "kittens", sorting by date instead.')
        end

        it 'should not be a hard failure' do
          expect(event_search).not_to be_hard_failure
        end
      end

      context 'when the search encounters an error' do
        before { allow(Event).to receive(:search).and_raise(ActiveRecord::StatementInvalid, 'bad times') }
        before { event_search.events }

        it 'should set a failure message' do
          expect(event_search.failure_message).to eq('There was an error completing your search.')
        end

        it 'should be a hard failure' do
          expect(event_search).to be_hard_failure
        end

        it 'should return no events' do
          expect(event_search.events).to be_empty
        end
      end
    end

    describe 'by tag' do
      let(:search_params) { { tag: 'foo' } }

      it 'should find all events matching the tag, ordered by date' do
        event_search.events
        expect(Event).to have_received(:search_tag).with('foo', current: false, order: 'date')
      end

      context 'with an invalid order' do
        let(:search_params) { { tag: 'omg', order: 'kittens' } }

        it 'should set a failure message as a warning' do
          expect(event_search.failure_message).to eq('Unknown ordering option "kittens", sorting by date instead.')
        end

        it 'should not be a hard failure' do
          expect(subject).not_to be_hard_failure
        end
      end

      context 'attempting to order by score' do
        let(:search_params) { { tag: 'omg', order: 'score' } }

        it 'should set a failure message as a warning' do
          expect(event_search.failure_message).to eq('You cannot sort tags by score')
        end

        it 'should not be a hard failure' do
          expect(event_search).not_to be_hard_failure
        end
      end

      context 'when the tag search encounters an error' do
        before { allow(Event).to receive(:search_tag).and_raise(ActiveRecord::StatementInvalid.new('bad times')) }
        before { event_search.events }

        it 'should set a failure message' do
          expect(event_search.failure_message).to eq('There was an error completing your search.')
        end

        it 'should be a hard failure' do
          expect(event_search).to be_hard_failure
        end

        it 'should return no events' do
          expect(event_search.events).to be_empty
        end
      end
    end

    describe '#grouped_events' do
      let(:past_event) { double(:event, current?: false) }
      let(:current_event) { double(:event, current?: true) }
      let(:events) { [past_event, current_event] }
      let(:search_params) { { query: 'ruby' } }

      it 'groups events into a hash by currentness' do
        expect(event_search.grouped_events).to eq(
          past: [past_event],
          current: [current_event]
        )
      end

      context "when passed the 'current' option" do
        let(:search_params) { { query: 'ruby', current: 'true' } }

        it 'discards past events' do
          expect(event_search.grouped_events).to eq(
            past: [],
            current: [current_event]
          )
        end
      end

      context "when passing 'date' to the order option" do
        let(:search_params) { { query: 'ruby', order: 'date' } }

        let(:other_past_event) { double(:event, current?: false) }
        let(:events) { [current_event, past_event, other_past_event] }

        it 'orders past events by date desc' do
          expect(event_search.grouped_events).to eq(
            current: [current_event],
            past: [past_event, other_past_event]
          )
        end
      end
    end

    describe 'hard failures' do
      context 'when given neither search query nor tag' do
        let(:search_params) { {} }

        it 'should set a failure message' do
          expect(event_search.failure_message).to eq('You must enter a search query')
        end

        it 'should be a hard failure' do
          expect(event_search).to be_hard_failure
        end

        it 'should return no events' do
          expect(event_search.events).to be_empty
        end
      end

      context 'when given both search query and tag' do
        let(:search_params) { { query: 'omg', tag: 'bbq' } }

        it 'should set a failure message' do
          expect(event_search.failure_message).to eq("You can't search by tag and query at the same time")
        end

        it 'should be a hard failure' do
          expect(event_search).to be_hard_failure
        end

        it 'should return no events' do
          expect(event_search.events).to be_empty
        end
      end
    end
  end
end