require 'spec_helper'

describe AuthStrategist::StrategyInterface do
  let(:default_components) { AuthStrategist.configuration.default_strategy_components }
  let(:strategy_class) { MissingAuthorize }

  context 'included' do
    it 'adds .define_components method to base' do
      expect(strategy_class).to respond_to(:define_components)
    end

    it 'adds .default_components method to base' do
      expect(strategy_class).to respond_to(:default_components)
    end

    it 'adds .components method to base' do
      expect(strategy_class).to respond_to(:components)
    end

    it 'adds constructor (.new method) to base' do
      expect(strategy_class).to respond_to(:new)
    end

    it 'adds #components method to base' do
      expect(strategy_class.new).to respond_to(:components)
    end

    it 'adds #authorize! method to base' do
      expect(strategy_class.new).to respond_to(:authorize!)
    end

    it 'adds getters for default components to base' do
      default_components.each do |c|
        expect(strategy_class.new).to respond_to(c)
      end
    end

    it 'adds setters for default components to base' do
      default_components.each do |c|
        expect(strategy_class.new).to respond_to("#{c}=")
      end
    end

    describe '.define_components' do
      before(:each) do
        strategy_class.define_components(*components)
      end

      context 'when component names are not the same as default' do
        let(:components) { [:user, :password] }

        it 'adds components getters' do
          components.each { |c| expect(strategy_class.new).to respond_to(c) }
        end

        it 'adds components setters' do
          components.each { |c| expect(strategy_class.new).to respond_to("#{c}=") }
        end

        it 'adds components to components list' do
          expect(strategy_class.components & components).to eq(components)
        end
      end

      context 'when component names are the same as default' do
        let(:components) { default_components }

        it 'is not being added to components list' do
          expect(strategy_class.components).to eq(strategy_class.components.uniq)
        end
      end

      context 'when no components provided' do
        let(:components) {}

        it 'is equal to .default_components' do
          expect(strategy_class.components).to eq(strategy_class.default_components)
        end
      end
    end

    describe '.default_components' do
      context 'for default specs environment configuration' do
        subject { strategy_class }

        its(:default_components) do
          is_expected.to eq(default_components)
        end
      end

      context 'for any configuration' do
        let(:components) { [:application, :requestor] }

        before(:each) do
          AuthStrategist.configure do |c|
            c.default_strategy_components = components
          end
        end

        it 'returns components configured as default' do
          expect(strategy_class.default_components).to eq(components)
        end
      end
    end

    describe '.components' do
      let(:components) { [*default_components, :dup, :dup] }

      before(:each) do
        strategy_class.define_components(*components)
      end

      it 'returns default and stratagy specific components without duplicates' do
        expect(strategy_class.components).to eq(components.uniq)
      end
    end

    describe '.new' do
      let(:options) { Hash[:user, 'john', :password, 'rambo'] }

      before(:each) do
        strategy_class.define_components(*options.keys)
        options[:missing_component] = :missing_component
      end

      subject { strategy_class.new(options) }

      it 'assigns components values properly' do
        expect(subject.user).to eq('john')
        expect(subject.password).to eq('rambo')
        expect { subject.missing_component }.to raise_error
      end
    end

    describe '#components' do
      subject { strategy_class.new }

      before(:each) do
        allow(strategy_class).to receive(:components).and_return([:ok])
      end

      it 'calls .components on strategy class' do
        expect(subject.components).to eq([:ok])
      end
    end

    describe '#authorize!' do
      subject { strategy_class.new }

      context 'when not implemented within base' do
        it 'returns nil' do
          expect(subject.authorize!).to be_nil
        end
      end

      context 'when implemented within base' do
        let(:strategy_class) { DummyStrategy }
        subject { strategy_class.new(dummy_component: :ok) }

        it 'executes like defined' do
          expect(subject.authorize!).to eq(:ok)
        end
      end
    end
  end
end