require 'workers/stack_sync_worker'
require 'lib/executors/stack_executor'

RSpec.describe StackSyncWorker, type: :worker, stubbed_connector: true, init_messages: true do
  let(:worker) { described_class.new }
  let(:stack) { build(:stack) }
  let(:perform) { worker.perform('stack_name' => 'stack') }
  let(:executor) {
    instance_double(Devops::Executor::StackExecutor,
      delete_stale_servers: nil,
      persist_new_servers: nil,
      bootstrap_just_persisted: double('result', reason: 'ok', code: 0)
    )
  }

  before do
    allow(worker).to receive(:update_report)
    allow(worker).to receive(:executor) { executor }
    allow(worker).to receive(:sleep)
    allow(stubbed_connector).to receive(:stack) { stack }
    allow(stubbed_connector).to receive(:lock_persisting_stack)
    allow(stubbed_connector).to receive(:unlock_persisting_stack)
  end

  it 'saves report with owner set to SYSTEM' do
    expect(worker).to receive(:update_report) do |options|
      expect(options).to include('created_by' => 'SYSTEM')
    end
    perform
  end

  it 'locks persisting of a stack before start and unlocks after finish' do
    expect(worker).to receive(:wait_until_stack_is_unlocked).ordered
    expect(stack).to receive(:lock_persisting!).ordered
    expect(executor).to receive(:delete_stale_servers).ordered
    expect(executor).to receive(:persist_new_servers).ordered
    expect(stack).to receive(:unlock_persisting!).ordered
    perform
  end

  it 'unlocks persisting even in case of failures' do
    allow(executor).to receive(:persist_new_servers) { raise }
    expect(stack).to receive(:unlock_persisting!)
    expect { perform }.to raise_error StandardError
  end

  it 'waites until stack is unlocked' do
    allow(stubbed_connector).to receive(:stack).and_return(
      build(:stack, persisting_is_locked: true),
      build(:stack, persisting_is_locked: true),
      build(:stack, persisting_is_locked: false)
    )
    expect(worker).to receive(:sleep).exactly(2).times
    perform
  end

end