require 'db/mongo/models/project'
require_relative 'shared_models_context'

RSpec.describe Devops::Model::Project, type: :model do
  let(:project) { build(:project) }
  include_context 'stubbed calls to connector in env validators'

  describe 'validation rules:' do
    include_examples 'field type validation', :id, :not_nil, :non_empty_string
    include_examples 'field type validation', :deploy_envs, :not_nil, :non_empty_array
    include_examples 'field type validation', :description, :maybe_nil, :maybe_empty_string
    include_examples 'field type validation', :run_list, :not_nil, :maybe_empty_array, :run_list

    it "isn't valid when has envs with same identifier" do
      project = build(:project, with_deploy_env_identifiers: %w(foo foo))
      expect(project).not_to be_valid
    end

    it "is valid when all envs have uniq identifiers" do
      project = build(:project, with_deploy_env_identifiers: %w(foo bar))
      expect(project).to be_valid
    end

    it "isn't valid when at least one of envs isn't valid" do
      project = build(:project, with_deploy_env_identifiers: ['foo', nil])
      expect(project).not_to be_valid
    end
  end

  describe '.fields' do
    subject { described_class.fields }
    it { should eq %w(deploy_envs type description) }
  end

  describe '#initialize' do
    it 'sets @type to generic by default' do
      expect(described_class.new.type).to eq 'generic'
    end

    it 'sets @archived to false by default' do
      expect(described_class.new.archived).to eq false
    end

    it 'sets run_list to empty_array by default' do
      expect(described_class.new.run_list).to eq []
    end

    describe 'deploy envs building' do
      let(:params) { {'deploy_envs' => [ {'provider' => @env_provider, 'identifier' => 'foo'} ]} }

      it 'builds envs array from given params' do
        @env_provider = 'ec2'
        expect(
          described_class.new(params).deploy_envs
        ).to be_an_array_of(Devops::Model::DeployEnvEc2).and have_size(1)
      end

      it 'builds ec2 deploy envs from given params' do
        @env_provider = 'ec2'
        builded_env = described_class.new(params).deploy_envs.first
        expect(builded_env).to be_a(Devops::Model::DeployEnvEc2)
        expect(builded_env.identifier).to eq 'foo'
      end

      it 'build openstack deploy envs from given params' do
        @env_provider = 'openstack'
        builded_env = described_class.new(params).deploy_envs.first
        expect(builded_env).to be_a(Devops::Model::DeployEnvOpenstack)
      end

      it 'build static deploy envs from given params' do
        @env_provider = 'static'
        builded_env = described_class.new(params).deploy_envs.first
        expect(builded_env).to be_a(Devops::Model::DeployEnvStatic)
      end
    end
  end

  describe '#deploy_env' do
    let(:project) { project = build(:project, with_deploy_env_identifiers: %w(foo bar)) }

    it 'returns found env' do
      expect(project.deploy_env('bar')).to be_an(Devops::Model::DeployEnvEc2)
    end

    it 'raises RecordNotFound if there is no such env' do
      expect {
        project.deploy_env('missing')
      }.to raise_error RecordNotFound
    end
  end

  describe '#add_deploy_env', stub_logger: true do
    let(:env) {build(:deploy_env_ec2)}
    subject { project.add_deploy_env(env) }
    before do
      allow(Devops::Db).to receive_message_chain('connector.add_deploy_env_to_project')
    end

    it 'inserts deploy env into mongo via connector' do
      expect(
        Devops::Db
      ).to receive_message_chain('connector.add_deploy_env_to_project').with(project.id, env)
      subject
    end

    it 'creates chef role' do
      expect(env).to receive(:create_role).with(project.id)
      subject
    end

    it 'returns string' do
      expect(subject).to be_a(String)
    end
  end

  describe '#add_authorized_user' do
    before do
      allow(Devops::Db).to receive_message_chain('connector.set_project_deploy_env_field')
    end
    let(:env1) { build(:deploy_env_ec2, identifier: 'foo') }
    let(:env2) { build(:deploy_env_ec2, identifier: 'bar') }
    let(:project) { build(:project, deploy_envs: [env1, env2]) }

    it 'returns nil if user is nil' do
      expect(project.add_authorized_user(nil)).to be_nil
    end

    context "when env isn't given" do
      context 'when user is a String' do
        it 'adds given user to all envs' do
          project.add_authorized_user('John')
          expect(env1.users).to match_array(%w(root John))
          expect(env2.users).to match_array(%w(root John))
        end
      end

      context 'when user is an Array of strings' do
        it 'adds given users to all envs' do
          project.add_authorized_user(['John', 'Matz'])
          expect(env1.users).to match_array(%w(root John Matz))
          expect(env2.users).to match_array(%w(root John Matz))
        end
      end
    end

    context 'when env is given' do
      context 'when user is a String' do
        it 'adds given user to given env' do
          project.add_authorized_user('John', 'bar')
          expect(env1.users).to match_array(%w(root))
          expect(env2.users).to match_array(%w(root John))
        end
      end

      context 'when user is an Array of strings' do
        it 'adds given users to all envs' do
          project.add_authorized_user(['John', 'Matz'], 'bar')
          expect(env1.users).to match_array(%w(root))
          expect(env2.users).to match_array(%w(root John Matz))
        end
      end
    end
  end

  describe '#remove_authorized_user' do
    before do
      allow(Devops::Db).to receive_message_chain('connector.set_project_deploy_env_field')
    end
    let(:env1) { build(:deploy_env_ec2, identifier: 'foo', users: %w(root John Matz)) }
    let(:env2) { build(:deploy_env_ec2, identifier: 'bar', users: %w(root John Matz)) }
    let(:project) { build(:project, deploy_envs: [env1, env2]) }

    it 'returns nil if user is nil' do
      expect(project.remove_authorized_user(nil)).to be_nil
    end

    context "when env isn't given" do
      context 'when user is a String' do
        it 'adds given user to all envs' do
          project.remove_authorized_user('John')
          expect(env1.users).to match_array(%w(root Matz))
          expect(env2.users).to match_array(%w(root Matz))
        end
      end

      context 'when user is an Array of strings' do
        it 'adds given users to all envs' do
          project.remove_authorized_user(['John', 'Matz'])
          expect(env1.users).to match_array(%w(root))
          expect(env2.users).to match_array(%w(root))
        end
      end
    end

    context 'when env is given' do
      context 'when user is a String' do
        it 'adds given user to given env' do
          project.remove_authorized_user('John', 'bar')
          expect(env1.users).to match_array(%w(root John Matz))
          expect(env2.users).to match_array(%w(root Matz))
        end
      end

      context 'when user is an Array of strings' do
        it 'adds given users to all envs' do
          project.remove_authorized_user(['John', 'Matz'], 'bar')
          expect(env1.users).to match_array(%w(root John Matz))
          expect(env2.users).to match_array(%w(root))
        end
      end
    end
  end

  describe '#check_authorization' do
    subject { project.check_authorization(@user || 'Matz', 'foo') }

    it 'returns true for root user' do
      @user = 'root'
      expect(subject).to be true
    end

    it "returns false if env's users don't include given user" do
      expect(subject).to be false
    end

    it "returns true if env's users include given user" do
      project.deploy_env('foo').users = %w(root Matz)
      expect(subject).to be true
    end

    it 'returns false if there is no such env' do
      expect(project.check_authorization('root', 'wrong')).to be false
    end
  end

  describe '#delete_deploy_env' do
    it 'removes env' do
      allow(Devops::Db).to receive_message_chain('connector.remove_deploy_env_from_project')
      expect(Devops::Db).to receive_message_chain('connector.remove_deploy_env_from_project').with(project.id, 'foo')
      project.delete_deploy_env('foo')
      expect(project.deploy_envs).to match_array []
    end
  end

  describe '#to_hash' do
    subject { project.to_hash }
    it 'returns hash' do
     expect(subject).to be_a(Hash)
    end

    it 'contains project id under name key' do
      expect(subject['name']).to eq project.id
    end

    it 'contains deploy_envs converted to hashes' do
      expect(subject['deploy_envs']).to be_an_array_of(Hash)
    end

    it 'also contains descriptions and run_list' do
      expect(subject).to include('description', 'run_list')
    end

    it 'contains archived key if project is archived' do
      project.archived = true
      expect(subject).to include('archived')
    end

    it "doesn't contain archived if project isn't archived" do
      expect(subject).not_to include('archived')
    end
  end

end