vagrant-ansible_auto 0.1.5 → 0.2.1

data/spec/unit/vagrant/ansible_auto/inventory_spec.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'vagrant/ansible_auto/errors'
+require 'vagrant/ansible_auto/inventory'
+
+describe VagrantPlugins::AnsibleAuto::Inventory do
+  include_context 'inventory'
+
+  let(:inventory_hosts) { %w[db bastion firewall] }
+
+  let(:complex_group) do
+    {
+      hosts: inventory_hosts,
+      vars: {
+        this: 'n',
+        uh: 'that',
+        n: 'uh'
+      },
+      children: %w[staging qa]
+    }
+  end
+
+  describe '#add_group' do
+    it 'adds a list of hosts to the group cache' do
+      inventory.add_group(:mygroup, *inventory_hosts)
+      inventory.groups.tap do |groups|
+        expect(groups).to have_key('mygroup')
+        expect(groups['mygroup']).to include(*inventory_hosts)
+      end
+    end
+
+    it 'appends new hosts to existing groups' do
+      inventory.add_group(:mygroup, *inventory_hosts)
+      inventory.add_group(:mygroup, 'repo')
+      inventory.groups.tap do |groups|
+        expect(groups).to have_key('mygroup')
+        expect(groups['mygroup']).to include('repo', *inventory_hosts)
+      end
+    end
+
+    it 'recognizes a hash in the style returned by executable inventories' do
+      inventory.add_group(:mygroup, complex_group)
+
+      inventory.groups.tap do |groups|
+        expect(groups).to have_key('mygroup')
+        expect(groups['mygroup']).to include(*inventory_hosts)
+      end
+
+      inventory.vars.tap do |vars|
+        expect(vars).to have_key('mygroup')
+        expect(vars['mygroup']).to include(this: 'n', uh: 'that', n: 'uh')
+      end
+
+      inventory.children.tap do |children|
+        expect(children).to have_key('mygroup')
+        expect(children['mygroup']).to include('staging', 'qa')
+      end
+    end
+
+    context 'given an invalid group name' do
+      it 'raises an error' do
+        expect { inventory.add_group('_') }.to raise_error do |error|
+          expect(error).to be_a(VagrantPlugins::AnsibleAuto::InvalidGroupNameError)
+          expect(error.message).to match(/_ is not a valid group name/)
+        end
+      end
+    end
+  end
+
+  describe '#add_host' do
+    include_context 'host'
+
+    it 'adds a host to the host cache' do
+      inventory.add_host(host)
+      expect(inventory.hosts).to include(host)
+    end
+
+    it 'does not allow duplicates' do
+      2.times { inventory.add_host(host) }
+      expect(inventory.hosts.size).to eq 1
+    end
+
+    it 'coerces instances of Vagrant::Machine to instances of Host' do
+      inventory.add_host(machine)
+      expect(inventory.hosts).to all(be_a(VagrantPlugins::AnsibleAuto::Host))
+    end
+
+    it 'coerces names + hostvars to instances of Host' do
+      inventory.add_host('mymachine', ssh_host: 'foo.bar.net')
+      mymachine = VagrantPlugins::AnsibleAuto::Host.new('mymachine', ssh_host: 'foo.bar.net')
+      expect(inventory.hosts).to all(be_a(VagrantPlugins::AnsibleAuto::Host))
+      expect(inventory.hosts).to include(mymachine)
+    end
+
+    context 'given an object that cannot be converted to a Host or HostMachine' do
+      it 'raises an error' do
+        expect { inventory.add_host(6) }.to raise_error(
+          VagrantPlugins::AnsibleAuto::Errors::InvalidHostTypeError,
+          /cannot add object of type \w+ as inventory host/
+        )
+      end
+    end
+  end
+
+  describe '#groups=' do
+    let(:new_groups) do
+      {
+        'foo'   => %w[bar baz quux],
+        'pink'  => %w[elephants on parade]
+      }
+    end
+
+    before do
+      inventory.groups = new_groups
+    end
+
+    it 'assigns the groups to the inventory' do
+      expect(inventory.groups['foo']).to include('bar', 'baz', 'quux')
+      expect(inventory.groups['pink']).to include('elephants', 'on', 'parade')
+    end
+
+    context 'given a :vars group' do
+      let(:group_vars) do
+        {
+          'this'  => 'that',
+          'some'  => 'thing'
+        }
+      end
+
+      let(:new_groups) do
+        {
+          'foo'       => %w[mee maw],
+          'foo:vars'  => group_vars
+        }
+      end
+
+      it 'assigns the vars to the given group' do
+        expect(inventory.vars['foo']).to include(group_vars)
+      end
+    end
+
+    context 'given a :children group' do
+      let(:group_children) do
+        %w[baz quux]
+      end
+
+      let(:new_groups) do
+        {
+          'foo'           => %w[d chain],
+          'foo:children'  => group_children
+        }
+      end
+
+      it 'assigns the provided groups as children of the parent group' do
+        expect(inventory.children['foo']).to include(*group_children)
+      end
+    end
+
+    context 'given a colon-separated group name without :vars or :children' do
+      let(:new_groups) do
+        {
+          'bleep'       => %w[ing computer],
+          'bleep:bloop' => %w[er reel]
+        }
+      end
+
+      it 'treats the group heading as a simple group name' do
+        expect(inventory.groups).to include('bleep:bloop')
+      end
+    end
+
+    context 'given a colon-separated group with backslash-escaped :vars or :children' do
+      let(:new_groups) do
+        {
+          'bleep'       => %w[ing computer],
+          'bleep\:vars' => %w[ity lacrosse],
+          'bleep\:children' => %w[of the corn]
+        }
+      end
+
+      it 'treats the group heading as a simple group name' do
+        expect(inventory.groups).to include('bleep\:vars')
+        expect(inventory.groups).to include('bleep\:children')
+        expect(inventory.vars[:bleep]).to be_empty
+        expect(inventory.children[:bleep]).to be_empty
+      end
+    end
+  end
+
+  describe '#groups' do
+    it 'returns a hash of sets' do
+      expect(inventory.groups).to be_a(Hash)
+      expect(inventory.groups[:foo]).to be_a(Set)
+    end
+  end
+
+  describe '#hosts=' do
+    it 'sets the hosts for the inventory' do
+      inventory.hosts = %w[huey dewey louie]
+      expect(inventory.hosts.map(&:name)).to eq(%w[huey dewey louie])
+    end
+
+    it 'wipes out any existing hosts' do
+      inventory.hosts = %w[huey dewey louie]
+      expect(inventory.hosts.map(&:name)).to eq(%w[huey dewey louie])
+      inventory.hosts = %w[heckle jeckle]
+      expect(inventory.hosts.map(&:name)).to eq(%w[heckle jeckle])
+    end
+  end
+
+  describe '#hosts' do
+    it 'returns a set' do
+      expect(inventory.hosts).to be_a(Set)
+    end
+  end
+
+  describe '#vars=' do
+    it 'sets the vars for the inventory' do
+      inventory.vars = { bah: { hum: 'bug' } }
+      expect(inventory.vars).to eq('bah' => { 'hum' => 'bug' })
+    end
+
+    it 'wipes out existing vars' do
+      inventory.vars = { bah: { hum: 'bug' } }
+      expect(inventory.vars).to eq('bah' => { 'hum' => 'bug' })
+      inventory.vars = { bah: { ram: 'ewe' } }
+      expect(inventory.vars).to eq('bah' => { 'ram' => 'ewe' })
+    end
+  end
+
+  describe '#vars' do
+    it 'returns a hash of hashes' do
+      expect(inventory.vars).to be_a(Hash)
+      expect(inventory.vars[:meh]).to be_a(Hash)
+    end
+  end
+
+  describe '#children=' do
+    it 'sets the group children for the inventory' do
+      inventory.children = { cronus: ['zeus'] }
+      expect(inventory.children.keys).to include('cronus')
+      expect(inventory.children[:cronus]).to include('zeus')
+    end
+
+    it 'wipes out any existing children' do
+      inventory.children = { cronus: ['zeus'] }
+      expect(inventory.children.keys).to include('cronus')
+      expect(inventory.children[:cronus]).to include('zeus')
+      inventory.children = { saturn: ['jupiter'] }
+      expect(inventory.children.keys).to include('saturn')
+      expect(inventory.children.keys).not_to include('cronus')
+      expect(inventory.children[:saturn]).to include('jupiter')
+      expect(inventory.children[:cronus]).not_to include('zeus')
+    end
+  end
+
+  describe '#children' do
+    it 'returns a hash of sets' do
+      expect(inventory.children).to be_a(Hash)
+      expect(inventory.children[:quux]).to be_a(Set)
+    end
+  end
+
+  describe 'merge' do
+    let(:inventory2) { inventory.clone }
+
+    it 'returns a new inventory with hosts, groups, vars, and children merged' do
+      inventory.hosts = %w[huey dewey louie]
+      inventory.groups = { ducks: %w[huey dewey louie] }
+      inventory.children = { birds: %w[ducks] }
+      inventory.vars = { birds: { of: 'a feather' }, ducks: { out: 'quick' } }
+
+      inventory2.hosts = %w[heckle jeckle launchpad]
+      inventory2.groups = { crows: %w[heckle jeckle], ducks: %w[launchpad] }
+      inventory2.children = { birds: %w[crows] }
+      inventory2.vars = { birds: { on: 'the wing' }, crows: { with: 'delight' } }
+
+      inventory3 = inventory.merge(inventory2)
+      expect(inventory3.hosts.map(&:name)).to include('huey', 'dewey', 'louie', 'launchpad', 'heckle', 'jeckle')
+      expect(inventory3.vars).to eq('birds' => { 'on' => 'the wing', 'of' => 'a feather' }, 'ducks' => { 'out' => 'quick' }, 'crows' => { 'with' => 'delight' })
+      expect(inventory3.groups.keys).to include('ducks', 'crows')
+      expect(inventory3.children['birds']).to include('ducks', 'crows')
+    end
+  end
+
+  describe '#hostvars' do
+    it "returns a hash each host's hostvars mapped to its inventory hostname"
+  end
+
+  describe '#validate!' do
+    context 'when nonextant children are defined for a group' do
+      it 'raises an error' do
+        inventory.groups = ['parent']
+        inventory.children_of('parent', 'child')
+        expect { inventory.validate! }.to raise_error(
+          VagrantPlugins::AnsibleAuto::Errors::GroupMissingChildError,
+          /group parent defines nonextant child group child/
+        )
+      end
+    end
+  end
+
+  describe '#to_ini' do
+    include_context 'host'
+
+    let(:host1) do
+      VagrantPlugins::AnsibleAuto::Host.new('blurgh').tap do |h|
+        h.inventory_hostname            = 'tweedledee'
+        h.ansible_ssh_user              = 'me'
+        h.ansible_ssh_host              = '10.10.0.20'
+        h.ansible_ssh_port              = 2200
+        h.ansible_ssh_private_key_file  = 'me_id_rsa'
+      end
+    end
+
+    let(:host2) do
+      VagrantPlugins::AnsibleAuto::Host.new('bleh').tap do |h|
+        h.inventory_hostname            = 'tweedledum'
+        h.ansible_ssh_user              = 'you'
+        h.ansible_ssh_host              = '192.168.1.88'
+        h.ansible_ssh_port              = 2201
+        h.ansible_ssh_private_key_file  = 'you_id_rsa'
+      end
+    end
+
+    it 'returns the inventory as an INI-style document' do
+      inventory.add_group(:mygroup, complex_group)
+      inventory.add_host(host1)
+      inventory.add_host(host2)
+      expect(inventory.to_ini).to eq(unindent(<<-INVENTORY).chomp)
+        tweedledee ansible_ssh_host=10.10.0.20 ansible_ssh_port=2200 ansible_ssh_private_key_file=me_id_rsa ansible_ssh_user=me
+        tweedledum ansible_ssh_host=192.168.1.88 ansible_ssh_port=2201 ansible_ssh_private_key_file=you_id_rsa ansible_ssh_user=you
+        [mygroup]
+        bastion
+        db
+        firewall
+        [mygroup:children]
+        qa
+        staging
+        [mygroup:vars]
+        n = uh
+        this = n
+        uh = that
+      INVENTORY
+    end
+  end
+end

data/spec/unit/vagrant/ansible_auto/provisioner_spec.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'log4r'
+
+require 'vagrant/config/v2/dummy_config'
+
+require 'vagrant/ansible_auto/provisioner'
+
+describe VagrantPlugins::AnsibleAuto::Provisioner do
+  include_context 'inventory'
+  include_context 'config'
+
+  def mock_capabilities(machine)
+    capabilities = {
+      ssh_server_address: ->(other) { [other.ssh_info[:host], other.ssh_info[:port]] },
+      authorized_key?: ->(content, *args) { [true] },
+      fetch_public_key: ->(path) {},
+      insert_public_key: ->(key) { [] },
+      ansible_installed: ->(*) { true }
+    }
+
+    allow(machine.guest).to receive(:capability?) { |cap| capabilities.key? cap }
+
+    allow(machine.guest).to receive(:capability) do |cap, *args, &block|
+      capabilities[cap].call(*args, &block) if capabilities.key? cap
+    end
+  end
+
+  let(:provisioner) { described_class.new(machine, config) }
+  let(:root_config) { Vagrant::Config::V2::DummyConfig.new }
+  let(:existing_file) { File.expand_path(__FILE__) }
+  let(:logger) { Log4r::Logger.new('vagrant::provisioners::ansible_auto::spec') }
+
+  before do |example|
+    unless example.metadata.fetch(:skip_before) { false }
+      # Allows us to set expectations on the provisioner's @logger instance
+      # variable
+      log4r_logger_new_original = Log4r::Logger.method(:new)
+      allow(Log4r::Logger).to receive(:new) do |namespace, *args|
+        if namespace == 'vagrant::provisioners::ansible_auto'
+          logger
+        else
+          log4r_logger_new_original.call(namespace, *args)
+        end
+      end
+
+      allow(root_config).to receive(:ansible).and_return(VagrantPlugins::AnsibleAuto::Config.new)
+
+      config.playbook = existing_file
+      config.finalize!
+      root_config.finalize!
+      machines.each do |m|
+        m.config.ansible.finalize!
+        mock_capabilities(m)
+      end
+
+      provisioner.configure(root_config)
+
+      allow(machine.communicate).to receive(:execute) do |*args|
+        0
+      end
+
+      allow(machine.communicate).to receive(:upload) do |*args|
+        true
+      end
+
+      allow(machine.communicate).to receive(:test) do |*args|
+        true
+      end
+    end
+  end
+
+  after do |example|
+    provisioner.provision unless example.metadata.fetch(:skip_after) { false }
+  end
+
+  describe '#provision' do
+    it 'creates an ansible inventory', skip_after: true do
+      expect(machine.communicate).to receive(:upload) do |from, to|
+        contents = File.read(from)
+        expect(contents).to match(/ansible_connection=local/)
+      end
+      expect { provisioner.provision }.not_to raise_error
+      expect(provisioner.config.inventory).to be_a VagrantPlugins::AnsibleAuto::Inventory
+    end
+
+    context 'when strict host key checking' do
+      let(:strict_host_key_checking_options) do
+        "ansible_ssh_extra_args='-o UserKnownHostsFile=/dev/null -o IdentitiesOnly=yes -o StrictHostKeyChecking=no'"
+      end
+
+      context 'is enabled' do
+        before do
+          config.strict_host_key_checking = true
+        end
+
+        it 'omits StrictHostKeyChecking=yes and other SSH options from the inventory' do
+          expect(machine.communicate).to receive(:upload) do |from, to|
+            contents = File.read(from)
+            expect(contents).not_to match(/#{strict_host_key_checking_options}/)
+          end
+        end
+      end
+
+      context 'is disabled' do
+        before do
+          config.strict_host_key_checking = false
+        end
+
+        it 'includes StrictHostKeyChecking=yes and other SSH options in the inventory' do
+          expect(machine.communicate).to receive(:upload) do |from, to|
+            contents = File.read(from)
+            expect(contents).to match(/#{strict_host_key_checking_options}/)
+          end
+        end
+      end
+    end
+
+    context 'when control machine public key insertion is enabled' do
+      let(:public_key_content) { 'iamapublickey' }
+      let(:private_key_content) { 'iamaprivatekey' }
+      let(:openssh_content) { 'ssh iamsomebinarystuff vagrant' }
+
+      before do
+        config.insert_control_machine_public_key = true
+        config.upload_inventory_host_private_keys = false
+      end
+
+      context 'and the control machine does not yet have a keypair configured' do
+        before do
+          allow(machine.communicate).to receive(:test).with(/^test -r/).and_return(false)
+          allow(Vagrant::Util::Keypair).to receive(:create).and_return([nil, private_key_content, openssh_content])
+        end
+
+        it 'creates and uploads a new keypair' do
+          expect(provisioner).to receive(:write_and_chown_and_chmod_remote_file).with(private_key_content, anything).and_call_original
+          expect(provisioner).to receive(:write_and_chown_and_chmod_remote_file).with(openssh_content, anything).and_call_original
+        end
+      end
+
+      context 'and the keypair is configured' do
+        before do
+          allow(provisioner).to receive(:control_machine_public_key).and_return(public_key_content)
+        end
+
+        context 'and the public key' do
+          context 'is already authorized' do
+            before do
+              machines[1..-1].each do |m|
+                allow(m.guest).to receive(:capability).with(:authorized_key?, public_key_content).and_return(true)
+              end
+            end
+
+            it 'does not attempt to insert the public key' do
+              machines[1..-1].each do |m|
+                expect(m.guest).not_to receive(:capability).with(:insert_public_key, public_key_content)
+              end
+            end
+          end
+
+          context 'is not authorized' do
+            before do
+              machines[1..-1].each do |m|
+                allow(m.guest).to receive(:capability).with(:authorized_key?, public_key_content).and_return(false)
+              end
+            end
+
+            context 'and the other host permits public key insertion' do
+              it 'attempts to insert the public key' do
+                machines[1..-1].each do |m|
+                  expect(m.guest).to receive(:capability).with(:insert_public_key, public_key_content)
+                end
+              end
+            end
+
+            context 'and the other host does not permit public key insertion' do
+              it 'issues a warning' do
+                machines[1..-1].each do |m|
+                  allow(m.guest).to receive(:capability?).with(:insert_public_key).and_return(false)
+                  expect(logger).to receive(:warn).with(/\ACannot insert control machine public key on/)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context 'when inventory host private key upload is enabled' do
+      let(:private_key_content) { 'iamaprivatekey' }
+
+      before do
+        config.insert_control_machine_public_key = false
+        config.upload_inventory_host_private_keys = true
+      end
+
+      context 'and the host has a private key configured' do
+        it 'uploads the private key to the control machine' do
+          machines[1..-1].each do |m|
+            expect(provisioner).to receive(:fetch_private_key).with(m).and_return(private_key_content)
+          end
+        end
+      end
+
+      context 'and the host does not have a private key configured' do
+        it 'issues a warning' do
+          machines[1..-1].each do |m|
+            allow(provisioner).to receive(:fetch_private_key).with(m).and_return(nil)
+            expect(logger).to receive(:warn).with(/\APrivate key for .*? not available for upload; provisioner will likely fail/)
+          end
+        end
+      end
+    end
+
+    context 'when both public key insertion and private key upload are disabled' do
+      before do
+        config.insert_control_machine_public_key = false
+        config.upload_inventory_host_private_keys = false
+      end
+
+      it 'issues a warning message' do
+        expect(machine.ui).to receive(:warn).with(/unable to insert public key or upload existing private key/).at_least(:once)
+      end
+    end
+
+    context 'given a machine that is not ready for SSH' do
+      before do
+        config.host_connect_tries = 1
+      end
+
+      it 'errors out if a machine is not ready for SSH', skip_after: true do
+        allow(machines[1].communicate).to receive(:ready?).and_return(false)
+        expect { provisioner.provision }.to raise_error(Vagrant::Errors::SSHNotReady)
+      end
+    end
+
+    context 'given a machine that is not configured for the current environment' do
+      it 'carps and ignores the machine', skip_after: true do
+        expect(logger).to receive(:warn).with(/\AMachine .*? not configured for this environment/).at_least(:once)
+        expect(logger).to receive(:warn).with(/\AUnable to find machine/).at_least(:once)
+        allow(machine.env).to receive(:machine).and_raise(Vagrant::Errors::MachineNotFound, name: 'dummy')
+        provisioner.provision
+      end
+    end
+  end
+end

data/spec/unit/vagrant/ansible_auto/util/config_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'vagrant/ansible_auto/util/config'
+
+describe VagrantPlugins::AnsibleAuto::Util::Config do
+  let(:including_klass) do
+    Class.new do
+      include VagrantPlugins::AnsibleAuto::Util::Config
+    end
+  end
+
+  before do
+    stub_const("#{including_klass.name}::UNSET_VALUE", Object.new)
+  end
+
+  let(:including_instance) { including_klass.new }
+  let(:unset_value) { including_klass.const_get :UNSET_VALUE }
+  let(:unset_values) { [nil, @meh, unset_value] }
+
+  describe '#unset?' do
+    context 'given a nil value, undefined value, or the special UNSET_VALUE object' do
+      it 'returns true' do
+        expect(unset_values.map { |o| including_instance.unset? o }).to all(be true)
+      end
+    end
+
+    context 'given anything else' do
+      it 'returns false' do
+        expect(['hey', 10, Object.new].map { |o| including_instance.unset? o }).to all(be false)
+      end
+    end
+  end
+
+  describe '#conditional_merge' do
+    context 'given unset values in the first argument' do
+      let(:righthand) { Object.new }
+
+      it 'returns the second argument' do
+        expect(unset_values.map { |o| including_instance.conditional_merge(o, righthand) }).to all(eq(righthand))
+      end
+    end
+
+    context 'given unset values in the second argument' do
+      let(:lefthand) { Object.new }
+
+      it 'returns the second argument' do
+        expect(unset_values.map { |o| including_instance.conditional_merge(lefthand, o) }).to all(eq(lefthand))
+      end
+    end
+
+    context 'given two hashes' do
+      let(:lefthand) { { a: 'hash', b: { real: 'dude' } } }
+      let(:righthand) { { b: { real: 'calm', and: %w[do not move] }, c: 'you later' } }
+      let(:merged) { { a: 'hash', b: { real: 'calm', and: %w[do not move] }, c: 'you later' } }
+
+      it 'merges the second argument into the first' do
+        expect(including_instance.conditional_merge(lefthand, righthand)).to eq(merged)
+      end
+    end
+  end
+end