fluke/devops-service/spec/workers/stack_servers_persister_spec.rb

require 'workers/stack_bootstrap/stack_servers_persister'

RSpec.describe StackServersPersister, stubbed_connector: true do
  let(:out) { double(:out, puts: nil, flush: nil) }
  let(:run_list) { ['role[asd]'] }
  let(:stack) { build(:stack, deploy_env: 'foo', run_list: run_list) }
  let(:project) { build(:project, id: 'name') }
  let(:persister) { described_class.new(stack, out) }
  let(:provider) { instance_double(Provider::Ec2, name: 'ec2') }
  let(:server_info_hash) do
    {
      'id' => 'server1',
      'name' => 'server_name',
      'key_name' => 'key',
      'private_ip' => '127.0.0.1',
      'public_ip' => '127.0.0.2',
      'tags' => {
        'cid:priority' => '3',
        'Name' => 'server1'
      }
    }
  end

  before do
    allow(stubbed_connector).to receive(:project) { project }
    allow(stubbed_connector).to receive(:image) {
      instance_double(Devops::Model::Image, remote_user: 'user')
    }
    allow(stubbed_connector).to receive(:server_insert)
    allow(stack).to receive(:provider_instance) { provider }
    allow(provider).to receive(:stack_servers) {[server_info_hash]}
  end

  describe '#persist' do
    it 'fetches stack servers info' do
      expect(provider).to receive(:stack_servers).with(stack)
      persister.persist
    end

    it "doesn't raise error if cid:priority tag is absent" do
      server_info_hash['tags'].delete('cid:priority')
      expect {persister.persist}.not_to raise_error
    end

    it 'returns hash {priority_as_integer => array of Devops::Model::Server}' do
      result = persister.persist
      expect(result).to be_a(Hash)
      expect(result[3]).to be_an_array_of(Devops::Model::Server).and have_size(1)
    end

    it 'takes id, key_name, private_ip and public_ip attrs from info hash' do
      expect(stubbed_connector).to receive(:server_insert) do |server|
        expect(server.id).to eq 'server1'
        expect(server.key).to eq 'key'
        expect(server.private_ip).to eq '127.0.0.1'
        expect(server.public_ip).to eq '127.0.0.2'
      end
      persister.persist
    end

    it 'takes created_by, run_list and stack attrs from stack' do
      expect(stubbed_connector).to receive(:server_insert) do |server|
        expect(server.created_by).to eq 'root'
        expect(server.run_list).to eq run_list
        expect(server.stack).to eq 'iamstack'
      end
      persister.persist
    end

    it 'takes remote_user from image user' do
      expect(stubbed_connector).to receive(:server_insert) do |server|
        expect(server.remote_user).to eq 'user'
      end
      persister.persist
    end

    it "takes deploy_env from project's deploy_env identifier" do
      expect(stubbed_connector).to receive(:server_insert) do |server|
        expect(server.deploy_env).to eq 'foo'
      end
      persister.persist
    end

    it "takes default provider's ssh key if info doesn't contain it" do
      allow(provider).to receive(:ssh_key) { 'default_key' }
      server_info_hash.delete('key_name')
      expect(stubbed_connector).to receive(:server_insert) do |server|
        expect(server.key).to eq 'default_key'
      end
      persister.persist
    end

    it "sets server's run list to empty array if stack's run_list is nil" do
      stack.run_list = nil
      expect(stubbed_connector).to receive(:server_insert) do |server|
        expect(server.run_list).to eq []
      end
      persister.persist
    end

    it 'build chef_node_name with default mask ":project-:instancename-:env"' do
      expect(stubbed_connector).to receive(:server_insert) do |server|
        expect(server.chef_node_name).to eq 'name-server1-foo'
      end
      persister.persist
    end

    it "builds chef_node_name with custom mask if info['tags']['cid:node-name-mask'] exists" do
      server_info_hash['tags']['cid:node-name-mask'] = ':project-:instancename-123'
      expect(stubbed_connector).to receive(:server_insert) do |server|
        expect(server.chef_node_name).to eq 'name-server1-123'
      end
      persister.persist
    end

    describe 'incremented variables' do
      it 'substitutes :increment-groupid: with incrementing numbers' do
        allow(provider).to receive(:stack_servers) {[
          {'id' => 'server1', 'tags' => {'cid:node-name-mask' => 'node-:increment-group1:-dev'}, 'key_name' => 'key'},
          {'id' => 'server1', 'tags' => {'cid:node-name-mask' => 'node-:increment-group1:-dev'}, 'key_name' => 'key'}
        ]}
        expect(stubbed_connector).to receive(:server_insert) do |server|
          expect(server.chef_node_name).to eq 'node-01-dev'
        end.ordered
        expect(stubbed_connector).to receive(:server_insert) do |server|
          expect(server.chef_node_name).to eq 'node-02-dev'
        end
        persister.persist
      end
    end
  end

end