require 'lib/executors/stack_executor'

class Devops::Executor::StackExecutor
  RSpec.describe self, type: :executor, stubbed_connector: true, stubbed_logger: true do
    let(:out) { double('out', puts: nil, flush: nil) }
    let(:stack) { build(:stack) }
    let(:executor_without_stack) { described_class.new(out: out) }
    let(:executor_with_stack) { described_class.new(out: out, stack: stack) }
    let(:new_servers_by_priorities) {
      {
        0 => [{'id' => 1}],
        2 => [{'id' => 2}]
      }
    }
    let(:fetcher) {
      instance_double(StackServersFetcher,
        servers_to_persist: new_servers_by_priorities.values.flatten,
        new_servers_by_priorities: new_servers_by_priorities,
        stale_servers: build_list(:server, 2),
        reset_states: nil
      )
    }

    let(:persister) { instance_double(StackServersPersister) }

    before do
      allow(executor_with_stack).to receive(:fetcher) { fetcher }
      allow(persister).to receive(:persist) { |info| build(:server, id: info['id']) }
      allow(executor_with_stack).to receive(:persister) { persister }
    end


    describe '#wait_till_stack_is_created' do
      let(:waiter) { instance_double(StackCreationWaiter, wait: double("creation_result", ok?: true)) }

      before do
        allow(executor_with_stack).to receive(:waiter) { waiter }
      end

      it "return true if syncer returns ok" do
        expect(waiter).to receive(:wait)
        expect(executor_with_stack.wait_till_stack_is_created).to be true
      end

      it "return false if syncer returns not ok" do
        allow(waiter).to receive(:wait) { double("creation_result", ok?: false, reason: '') }
        expect(executor_with_stack.wait_till_stack_is_created).to be false
      end
    end

    describe '#create_stack' do
      before { expect(stubbed_connector).to receive(:stack_insert) }

      it 'initiate creation in cloud and persists stack' do
        expect(Devops::Model::StackFactory).to receive(:create).with('ec2', instance_of(Hash), out)
        executor_with_stack.create_stack({'provider' => 'ec2'})
      end

      it 'locks persisting on create' do
        expect(Devops::Model::StackFactory).to receive(:create) do |_, params|
          expect(params).to include('persisting_is_locked' => true)
        end
        executor_with_stack.create_stack({'provider' => 'ec2'})
      end
    end

    describe '#persist_new_servers' do
      before do
        allow(stubbed_connector).to receive(:stack) { stack }
      end

      it 'calls StackServersPersister#persist for each server' do
        expect(persister).to receive(:persist).exactly(2).times
        executor_with_stack.persist_new_servers
      end
    end

    describe '#bootstrap_just_persisted' do
      subject {
        executor_with_stack.persist_new_servers
        executor_with_stack.bootstrap_just_persisted(1000)
      }

      it 'passes skip_rollback option equals to @stack.skip_rollback?' do
        allow(stack).to receive(:skip_rollback?) { 'test' }
        expect(PrioritizedGroupsBootstrapper).to receive(:new).with(
          hash_including(skip_rollback: 'test')
        ).and_return(double('groups bootstrapper', bootstrap_servers_by_priority: nil))
        subject
      end

      it 'calls PrioritizedGroupsBootstrapper#bootstrap_servers_by_priority' do
        expect_any_instance_of(PrioritizedGroupsBootstrapper).to receive(:bootstrap_servers_by_priority)
        subject
      end
    end

    describe '#delete_stale_servers' do
      it 'builds server executor per stale server and properly delete them' do
        executor1 = instance_double(Devops::Executor::ServerExecutor, delete_server: nil)
        executor2 = instance_double(Devops::Executor::ServerExecutor, delete_server: nil)
        allow(Devops::Executor::ServerExecutor).to receive(:new).and_return(executor1, executor2)
        expect(executor1).to receive(:delete_server).ordered
        expect(executor2).to receive(:delete_server).ordered
        executor_with_stack.delete_stale_servers
      end
    end

    describe '#delete_stack', stubbed_connector: true do
      it 'deletes stack from cloud, then deletes stack servers, and then deletes stack itself' do
        allow(stubbed_connector).to receive(:stack_servers) { [build(:server, id: 'i-persisted')] }
        expect(stack).to receive(:delete_stack_in_cloud!).ordered
        expect(stubbed_connector).to receive(:stack_servers).ordered
        expect(stubbed_connector).to receive(:stack_delete).ordered

        executor = instance_double(Devops::Executor::ServerExecutor, delete_server: nil)
        allow(Devops::Executor::ServerExecutor).to receive(:new) { executor }
        expect(executor).to receive(:delete_server)
        executor_with_stack.delete_stack
      end
    end
  end
end