vagrant-ansible_auto 0.1.5 → 0.2.1

data/spec/support/context.rb

@@ -0,0 +1,111 @@
+require 'vagrant'
+require Vagrant.source_root.join('test/unit/support/dummy_communicator')
+require 'vagrant-spec/unit'
+
+def unindent(s)
+  s.lines.tap do |lines|
+    indent = lines.map { |l| l.length - l.lstrip.length }.min
+    return lines.map { |l| l[indent..-1] }.join
+  end
+end
+
+shared_context 'machine' do |machine_count = 2|
+  include_context 'vagrant-unit'
+
+  def mock_communicator(machine)
+    VagrantTests::DummyCommunicator::Communicator.new(machine)
+  end
+
+  def mock_guest
+    double('guest')
+  end
+
+  def mock_machine_state
+    double('state').tap do |s|
+      allow(s).to receive(:id).and_return(:running)
+    end
+  end
+
+  def mock_ssh_info
+    {}.tap do |i|
+      allow(i).to receive(:[])
+      allow(i).to receive(:fetch).with(:private_key_path, anything).and_return([])
+    end
+  end
+
+  def mock_ui
+    Vagrant::UI::Colored.new
+  end
+
+  def mock_machine(name)
+    iso_env.machine(name, :dummy).tap do |m|
+      allow(m).to receive(:state).and_return(mock_machine_state)
+      allow(m).to receive(:ssh_info).and_return(mock_ssh_info)
+      allow(m).to receive(:ui).and_return(mock_ui)
+      allow(m).to receive(:communicate).and_return(mock_communicator(m))
+      allow(m).to receive(:guest).and_return(mock_guest)
+      allow(m.env).to receive(:active_machines).and_return(iso_env.machine_names.map { |n| [n, :dummy] })
+    end
+  end
+
+  let(:vagrantfile_contents) do
+    <<-VAGRANTFILE
+      Vagrant.configure(2) do |config|
+        config.vm.box = 'base'
+        #{(1..machine_count).map { |c| "config.vm.define :machine#{c}" }.join("\n")}
+      end
+    VAGRANTFILE
+  end
+
+  # Lifted from core Ansible provisioner tests
+  let(:iso_env) do
+    env = isolated_environment
+    env.vagrantfile(vagrantfile_contents)
+    env.create_vagrant_env
+  end
+
+  let(:machines) { iso_env.machine_names.map { |n| mock_machine(n) } }
+  let(:machine) { machines[0] }
+  let(:machine_name) { machine.name }
+  let(:state) { machine.state }
+  let(:ssh_info) { machine.ssh_info }
+  let(:ui) { machine.ui }
+  let(:communicator) { machine.communicator }
+  let(:playbook) { 'playbook.yml' }
+end
+
+shared_context 'host' do
+  require 'vagrant/ansible_auto/host'
+
+  include_context 'machine'
+
+  let(:hostvars) { {} }
+  let(:inventory_hostname) { machine_name.to_s }
+  let(:host) { VagrantPlugins::AnsibleAuto::Host.new(machine_name, hostvars) }
+  let(:host_machine) { VagrantPlugins::AnsibleAuto::HostMachine.new(machine, hostvars) }
+end
+
+shared_context 'inventory' do
+  require 'vagrant/ansible_auto/inventory'
+
+  include_context 'machine'
+
+  let(:inventory) { VagrantPlugins::AnsibleAuto::Inventory.new }
+end
+
+shared_context 'config' do
+  require 'vagrant/ansible_auto/config'
+
+  include_context 'machine'
+  include_context 'inventory'
+
+  let(:config) { VagrantPlugins::AnsibleAuto::Config.new }
+
+  before do
+    allow(config).to receive(:inventory).and_return(inventory)
+
+    machines.each do |m|
+      allow(m.config).to receive(:ansible).and_return(VagrantPlugins::AnsibleAuto::Config.new)
+    end
+  end
+end

data/spec/support/matchers.rb

@@ -0,0 +1,45 @@
+require 'rspec'
+
+# We're using an older version of rspec-expectations that doesn't have the
+# `all' matcher.
+RSpec::Matchers.define :all do |expected|
+  define_method :index_failed_objects do |actual|
+  end
+
+  def index_failed_objects(actual)
+    return enum_for(__method__, actual) unless block_given?
+
+    @failed_items = []
+
+    actual.each_with_index do |o, i|
+      @failed_items[i] = yield o
+    end
+
+    @failed_items.compact.empty?
+  end
+
+  match_for_should do |actual|
+    index_failed_objects(actual) do |item|
+      expected.failure_message_for_should unless expected.matches?(item)
+    end
+  end
+
+  match_for_should_not do |actual|
+    index_failed_objects(actual) do |item|
+      expected.failure_message_for_should_not if expected.matches?(item)
+    end
+  end
+
+  def failure_message(actual)
+    if actual.respond_to?(:each_with_index)
+      @failed_items.each_with_index.reject { |f, _i| f.nil? }.map do |f, i|
+        "object at index #{i} failed to match: #{f}"
+      end.join("\n")
+    else
+      'provided object is not iterable'
+    end
+  end
+
+  failure_message_for_should      { |actual| failure_message(actual) }
+  failure_message_for_should_not  { |actual| failure_message(actual) }
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'vagrant/ansible_auto/config'
+
+describe VagrantPlugins::AnsibleAuto::Config do
+  include_context 'config'
+
+  def validate_config(c, m, attr, v)
+    c.public_send("#{attr}=", v)
+    c.finalize!
+    errors = c.validate(m)
+    yield errors['ansible_auto']
+  end
+
+  describe '#validate' do
+    context 'given an invalid value for a configuration parameter' do
+      it 'catches the error and returns it under the "ansible_auto" key' do
+        described_class::BOOLEAN.each do |attr|
+          validate_config(config, machine, attr, 5) do |errors|
+            expect(errors).to include("#{attr} must be either true or false")
+          end
+        end
+
+        described_class::INTEGER.each do |attr|
+          validate_config(config, machine, attr, nil) do |errors|
+            expect(errors).to include("#{attr} must be an integer")
+          end
+        end
+
+        described_class::NUMBER.each do |attr|
+          validate_config(config, machine, attr, nil) do |errors|
+            expect(errors).to include("#{attr} must be a number")
+          end
+        end
+      end
+    end
+
+    context 'given an error constructing the inventory' do
+      it 'catches the error and returns it under the "ansible_auto" key' do
+        pending 'at the moment, the inventory object does not raise any errors along the relevant code paths' do
+          config.finalize!
+          errors = config.validate(machine)
+          expect(errors['ansible_auto']).not_to be_empty
+        end
+      end
+    end
+
+    context 'given a valid value for a configuration parameter' do
+      it 'does not catch the error and return it under the "ansible_auto" key' do
+        described_class::BOOLEAN.each do |attr|
+          validate_config(config, machine, attr, true) do |errors|
+            expect(errors).not_to include("#{attr} must be either true or false")
+          end
+        end
+
+        described_class::INTEGER.each do |attr|
+          validate_config(config, machine, attr, 10) do |errors|
+            expect(errors).not_to include("#{attr} must be an integer")
+          end
+        end
+
+        described_class::NUMBER.each do |attr|
+          validate_config(config, machine, attr, 3.14159) do |errors|
+            expect(errors).not_to include("#{attr} must be a number")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'vagrant/ansible_auto/host'
+
+describe VagrantPlugins::AnsibleAuto::Host do
+  include_context 'host'
+
+  let(:hostvars) do
+    {
+      ansible_ssh_user: 'me',
+      ansible_ssh_host: 'foo.bar.net',
+      ansible_ssh_port: 2222,
+      ansible_ssh_private_key_file: '/path/to/private_key'
+    }
+  end
+
+  describe '#name' do
+    it 'corresponds to the first parameter of the constructor' do
+      expect(host.name).to eq machine_name
+    end
+  end
+
+  describe '#inventory_hostname' do
+    it 'corresponds to the first parameter of the constructor, stringified' do
+      expect(host.inventory_hostname).to eq machine_name.to_s
+    end
+  end
+
+  describe '#ssh_user' do
+    it 'corresponds to hostvars[:ansible_ssh_user]' do
+      expect(host.ansible_ssh_user).to eq 'me'
+    end
+  end
+
+  describe '#ssh_host' do
+    it 'corresponds to hostvars[:ansible_ssh_host]' do
+      expect(host.ansible_ssh_host).to eq 'foo.bar.net'
+    end
+  end
+
+  describe '#ssh_port' do
+    it 'corresponds to hostvars[:ansible_ssh_port]' do
+      expect(host.ansible_ssh_port).to eq 2222
+    end
+  end
+
+  describe '#ssh_private_key_file' do
+    it 'corresponds to hostvars[:ansible_ssh_private_key_file]' do
+      expect(host.ansible_ssh_private_key_file).to eq '/path/to/private_key'
+    end
+  end
+
+  describe '#hostvars' do
+    it 'stringifies its keys' do
+      expect(host.hostvars).to eq(
+        'ansible_ssh_user'              => 'me',
+        'ansible_ssh_host'              => 'foo.bar.net',
+        'ansible_ssh_port'              => 2222,
+        'ansible_ssh_private_key_file'  => '/path/to/private_key'
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns #hostvars keyed to #inventory_hostname' do
+      expect(host.to_h).to eq(host.inventory_hostname => {
+                                'ansible_ssh_user'              => 'me',
+                                'ansible_ssh_host'              => 'foo.bar.net',
+                                'ansible_ssh_port'              => 2222,
+                                'ansible_ssh_private_key_file'  => '/path/to/private_key'
+                              })
+    end
+  end
+
+  describe "a method starting with `ansible_'" do
+    it 'dispatches to hostvars' do
+      host.ansible_python_interpreter = '/usr/bin/python2.7'
+      expect(host.ansible_python_interpreter).to eq '/usr/bin/python2.7'
+      expect(host.hostvars[:ansible_python_interpreter]).to eq '/usr/bin/python2.7'
+    end
+  end
+
+  describe '#to_ini' do
+    it 'returns #to_h as INI-style lines' do
+      expect(host.to_ini).to eq(unindent(<<-HOST).chomp)
+        #{inventory_hostname} ansible_ssh_host=foo.bar.net ansible_ssh_port=2222 ansible_ssh_private_key_file=/path/to/private_key ansible_ssh_user=me
+      HOST
+    end
+  end
+end
+
+describe VagrantPlugins::AnsibleAuto::HostMachine do
+  include_context 'host'
+
+  describe '#ansible_ssh_user' do
+    it 'corresponds to machine.ssh_info[:username]' do
+      expect(ssh_info).to receive(:[]).with(:username).and_return('me')
+      expect(host_machine.ansible_ssh_user).to eq 'me'
+    end
+  end
+
+  describe '#ansible_ssh_host' do
+    it 'corresponds to machine.ssh_info[:host]' do
+      expect(ssh_info).to receive(:[]).with(:host).and_return('foo.bar.net')
+      expect(host_machine.ansible_ssh_host).to eq 'foo.bar.net'
+    end
+  end
+
+  describe '#ansible_ssh_port' do
+    it 'corresponds to machine.ssh_info[:port]' do
+      expect(ssh_info).to receive(:[]).with(:port).and_return(2222)
+      expect(host_machine.ansible_ssh_port).to eq 2222
+    end
+  end
+
+  describe '#ansible_ssh_private_key_file' do
+    it 'corresponds to machine.ssh_info[:private_key_path]' do
+      expect(machine.config.ssh).to receive(:insert_key).and_return(true)
+      expect(ssh_info).to receive(:fetch).with(:private_key_path, anything).and_return(['/path/to/private_key'])
+      expect(host_machine.ansible_ssh_private_key_file).to eq '/path/to/private_key'
+    end
+
+    it 'has no default' do
+      expect(machine.config.ssh).to receive(:insert_key).and_return(true)
+      expect(ssh_info).to receive(:fetch).with(:private_key_path, anything).and_return([])
+      expect(host_machine.ansible_ssh_private_key_file).to be_nil
+    end
+  end
+end