vagrant_spec 0.0.1

data/lib/vagrant_spec/test_plan.rb

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+
+require 'rspec'
+
+require 'vagrant_spec/config'
+require 'vagrant_spec/machine_finder'
+
+module VagrantSpec
+  # Run serverspec tests
+  #
+  # env [Vagrant::Environment]
+  class TestPlan
+    attr_reader :env, :config, :test_plan, :m_finder
+    def initialize(env)
+      @env       = env
+      @config    = VagrantSpec::Config.load(env)
+      @test_plan = @config.spec.test_plan
+      @m_finder  = VagrantSpec::MachineFinder.new(env)
+      @ret_code  = 0
+    end
+
+    # Run the test suite and exit based on the return codes of the tests
+    #
+    # This will fail if any of the tests fail, but it will allow all tests to
+    # run
+    def run
+      @env.ui.info('*******************************************************')
+      @env.ui.info('***************** ServerSpec Test Run *****************')
+      @env.ui.info('*******************************************************')
+      @env.ui.info('')
+      @test_plan.each do |plan|
+        nodes(plan).each { |node| execute_plan_tests(node, plan) }
+      end
+      exit @ret_code
+    end
+
+    # Return array of active Vagrant machines
+    #
+    # plan   [Hash] item in the @config.spec.test_plan
+    #
+    # return [Array<Vagrant::Machine>]
+    def nodes(plan)
+      if plan['nodes'].is_a?(Regexp)
+        @m_finder.match_nodes(plan['nodes'])
+      elsif plan['nodes'].is_a?(Array)
+        plan['nodes'].collect { |n| @m_finder.machine(n.to_sym) }
+      end
+    end
+
+    # Execute a test_suite and return the code
+    #
+    # node [Vagrant::Machine]
+    # plan [Hash] item in the @config.spec.test_plan
+    #
+    # return [@ret_code]
+    def execute_plan_tests(node, plan)
+      @env.ui.info("[#{node.name}]")
+      ENV['VAGRANT_HOST'] = node.ssh_info[:host].to_s
+      ENV['VAGRANT_PORT'] = node.ssh_info[:port].to_s
+      ENV['VAGRANT_KEY']  = node.ssh_info[:private_key_path][0].to_s
+      ENV['VAGRANT_USER'] = node.ssh_info[:username].to_s
+      plan['flags'].prepend "-I #{@config.spec.directory} "
+      ret_code = RSpec::Core::Runner.run(plan['flags'].split, $stderr, $stdout)
+      RSpec.clear_examples
+      @ret_code = ret_code unless ret_code.zero?
+    end
+  end
+end

data/lib/vagrant_spec/utils.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module VagrantSpec
+  # Utilities
+  module Utils
+    # return [String]
+    def project_root
+      File.expand_path(File.join(File.dirname(__FILE__), '..', '..'), __FILE__)
+    end
+
+    # return [String]
+    def lib_root
+      File.expand_path(File.join(File.dirname(__FILE__), '..'), __FILE__)
+    end
+
+    # return [String]
+    def template_dir
+      File.expand_path(
+        File.join(lib_root, 'vagrant_spec', 'templates'), __FILE__
+      )
+    end
+  end
+end

data/lib/vagrant_spec/version.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+# Requisite version info
+module VagrantSpec
+  VERSION = '0.0.1'.freeze
+end

data/lib/vagrant_spec.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Vagrant plugin vagrant_spec must be run within Vagrant'
+end
+
+module VagrantSpec
+  # Plugin definitions
+  class Plugin < Vagrant.plugin(2)
+    name 'spec'
+    description <<-DESC
+    This plugin eases rspec and serverspec testing
+    DESC
+
+    command :spec do
+      require 'vagrant_spec/command/base'
+      VagrantSpec::Command::Base
+    end
+
+    config :spec do
+      require 'vagrant_spec/config/base'
+      VagrantSpec::Config::Base
+    end
+  end
+end

data/scripts/poor_mans_smoke_test.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+# This is purely for convenience. This has to be watched to verify that the
+# plugin works in a live environment. Better testing to come...
+
+set -e
+
+bundle exec vagrant spec
+bundle exec vagrant spec -h
+bundle exec vagrant spec init -h
+bundle exec vagrant spec test -h
+bundle exec vagrant spec no_command -h
+rm -f serverspec/spec_helper.rb
+bundle exec vagrant up
+bundle exec vagrant spec init
+bundle exec vagrant spec test || true
+bundle exec vagrant destroy -f 

data/serverspec/fail_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Thing that fails' do
+  it 'dumb_service totally fails' do
+    expect(service('dumb_service')).to be_running
+  end
+end

data/serverspec/ssh_spec.rb

@@ -0,0 +1,10 @@
+
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe 'ssh' do
+  it 'ssh should be running' do
+    expect(service('ssh')).to be_running
+  end
+end

data/spec/unit/spec_helper.rb

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'rspec'
+
+# Get path to vagrant's test directory so we can load that code. We'll want it
+# for getting access to its convenient shared methods and contexts and such
+VAGRANT_LIB_DIR  = Gem::Specification.find_by_name('vagrant').gem_dir.freeze
+VAGRANT_TEST_DIR = File.join(VAGRANT_LIB_DIR, 'test').freeze
+
+# Load code paths
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), __FILE__)
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path(VAGRANT_TEST_DIR, __FILE__)
+
+require 'vagrant'
+require 'vagrant_spec'
+
+require 'unit/support/shared/base_context'
+require 'unit/support/shared/virtualbox_context'
+
+# Build methods to retrieve plugins against VagrantSpec::Plugin.
+#
+# Example: get_commands(VagrantSpec::Plugin)
+#
+# The method call above will return an array of Command plugin names as symbols.
+# Add support by extending the symbol arrays as needed
+%i(command).each do |plugin|
+  plural = "#{plugin}s"
+  plural_symbol = plural.to_sym
+  method_name = "get_#{plural}"
+  define_method(method_name) do |plugin_obj|
+    plugin_obj.components.send(plural_symbol).keys
+  end
+end
+
+%i(config).each do |plugin|
+  plural = "#{plugin}s"
+  plural_symbol = plural.to_sym
+  method_name = "get_#{plural}"
+  define_method(method_name) do |plugin_obj|
+    plugin_obj.components.send(plural_symbol)[:top].keys
+  end
+end
+
+RSpec.shared_examples 'shared_mocks' do
+  let(:vagrant_file) do
+    <<-EOF.gsub(/^ {4}/, '')
+    Vagrant.configure(2) do |config|
+      config.vm.box = 'test'
+    end
+    EOF
+  end
+
+  let(:mock_vf_obj) { double(Vagrant::Vagrantfile)      }
+  let(:mock_ui)     { double(Vagrant::UI)               }
+  let(:mock_config) { double(Vagrant::Config)           }
+  let(:mock_spec)   { double(VagrantSpec::Config::Base) }
+  let(:mock_node)   { double(Vagrant::Machine)          }
+
+  let(:spec_dir)    { 'serverspec'                      }
+
+  let(:iso_env) do
+    env = isolated_environment
+    env.vagrantfile vagrant_file
+    env.create_vagrant_env
+    env
+  end
+
+  before do
+    allow(iso_env).to     receive(:ui)
+    allow(mock_node).to   receive(:name)
+    allow(mock_ui).to     receive(:info)
+
+    allow(iso_env).to     receive(:vagrantfile) { mock_vf_obj   }
+    allow(iso_env).to     receive(:ui)          { mock_ui       }
+    allow(mock_vf_obj).to receive(:config)      { mock_config   }
+    allow(mock_config).to receive(:spec)        { mock_spec     }
+    allow(mock_spec).to   receive(:directory)   { spec_dir      }
+  end
+end
+
+RSpec::Matchers.define :have_attr_accessor do |field|
+  match do |obj_i|
+    obj_i.respond_to?(field) && obj_i.respond_to?("#{field}=")
+  end
+
+  failure_message do |obj_i|
+    "expected attr_accessor for #{field} on #{obj_i}"
+  end
+
+  failure_message_when_negated do |obj_i|
+    "expected attr_accessor for #{field} not to be defined on #{obj_i}"
+  end
+
+  description do
+    'checks to see if there is an attr accessor on the supplied object'
+  end
+end

data/spec/unit/vagrant_spec_spec.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+require_relative 'spec_helper'
+
+describe VagrantSpec::Plugin do
+  it 'has a command plugin: spec' do
+    expect(get_commands(VagrantSpec::Plugin)).to include(:spec)
+  end
+
+  it 'has a config plugin: spec' do
+    expect(get_configs(VagrantSpec::Plugin)).to include(:spec)
+  end
+end

data/spec/unit/vagrant_spec_test/ansible_inventory_spec.rb

@@ -0,0 +1,143 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'vagrant_spec/ansible_inventory'
+
+describe VagrantSpec::AnsibleInventory do
+  include_context  'unit'
+  include_examples 'shared_mocks'
+
+  let(:mock_ansible_inventory_regexp) { { 'all' => /node/ } }
+  let(:mock_ansible_inventory_array) { { 'all' => %w(node1) } }
+
+  let(:mock_machine_ssh_config) do
+    {
+      'ansible_host'                  => 'node1',
+      'ansible_port'                  => '2222',
+      'ansible_user'                  => 'vagrant',
+      'ansible_ssh_private_key_file'  => 'mock_key'
+    }
+  end
+
+  subject { VagrantSpec::AnsibleInventory.new(iso_env) }
+
+  def load_ansible_inventory_proc
+    proc do
+      allow(subject).to  receive(:handle_array)
+      allow(subject).to  receive(:handle_regexp)
+    end
+  end
+
+  context 'when ansible_inventory is a Regexp' do
+    it '#load_ansible_inventory calls handle_regexp' do
+      allow(mock_spec).to receive(:ansible_inventory) do
+        mock_ansible_inventory_regexp
+      end
+      load_ansible_inventory_proc.call
+      expect(subject).to receive(:handle_regexp)
+      subject.load_ansible_inventory
+    end
+  end
+
+  context 'when ansibe_inventory is an Array' do
+    it '#load_ansible_inventory calls handle_array' do
+      allow(mock_spec).to receive(:ansible_inventory) do
+        mock_ansible_inventory_array
+      end
+
+      load_ansible_inventory_proc.call
+      expect(subject).to receive(:handle_array)
+      subject.load_ansible_inventory
+    end
+  end
+
+  it '#handle_array calls generate_machine_config on each node name' do
+    group = mock_ansible_inventory_array.keys[0]
+    nodes = mock_ansible_inventory_array.values[0]
+
+    allow(mock_spec).to receive(:ansible_inventory) do
+      mock_ansible_inventory_array
+    end
+
+    allow(subject).to  receive(:generate_machine_config)
+    expect(subject).to receive(:generate_machine_config).with(nodes[0])
+
+    subject.handle_array(group, nodes)
+  end
+
+  # Inject code into handle_regexp tests
+  def handle_regexp_proc
+    proc do
+      allow(mock_spec).to receive(:ansible_inventory) do
+        mock_ansible_inventory_regexp
+      end
+
+      allow(mock_node).to receive(:name) { 'node1' }
+      allow(subject).to   receive(:generate_machine_config)
+    end
+  end
+
+  context 'when nodes are matched' do
+    it '#handle_regexp calls generate_machine_config' do
+      handle_regexp_proc.call
+
+      allow(subject.m_finder).to receive(:match_nodes) { [mock_node] }
+      expect(subject).to receive(:generate_machine_config).with('node1')
+
+      subject.handle_regexp('all', /node/)
+    end
+  end
+
+  context 'when nodes are not matched' do
+    it '#handle_regexp does nothing' do
+      handle_regexp_proc.call
+
+      allow(subject.m_finder).to receive(:match_nodes) {}
+      expect(subject).to_not     receive(:generate_machine_config)
+
+      subject.handle_regexp('all', /node/)
+    end
+  end
+
+  def generate_machine_config_proc(_name)
+    proc do
+      allow(mock_spec).to receive(:ansible_inventory) do
+        mock_ansible_inventory_regexp
+      end
+
+      allow(subject).to receive(:machine_ssh_config) { mock_machine_ssh_config }
+    end
+  end
+
+  context 'when a node is found' do
+    it '#generate_machine_config calls machine_ssh_config' do
+      name = 'node1'
+      generate_machine_config_proc(name).call
+
+      allow(subject.m_finder).to receive(:machine).with(name.to_sym) do
+        mock_node
+      end
+
+      expect(subject).to receive(:machine_ssh_config) do
+        { 'name' => mock_machine_ssh_config }
+      end
+
+      subject.generate_machine_config(name)
+    end
+  end
+
+  context 'when a node is not found' do
+    it '#generate_machine_config does nothing' do
+      name = 'node1'
+      generate_machine_config_proc(name).call
+
+      allow(subject.m_finder).to receive(:machine).with(name.to_sym) {}
+
+      expect(subject).not_to receive(:machine_ssh_config) do
+        { 'name' => mock_machine_ssh_config }
+      end
+
+      subject.generate_machine_config(name)
+    end
+  end
+end

data/spec/unit/vagrant_spec_test/command_spec/base_spec.rb

@@ -0,0 +1,105 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'vagrant_spec/command/base'
+
+describe VagrantSpec::Command::Base do
+  include_context  'unit'
+  include_examples 'shared_mocks'
+
+  let(:mock_opts)     { double(OptionParser) }
+  let(:mock_registry) { double(Vagrant::Registry) }
+
+  before do
+    allow(Dir).to receive(:glob) { %w(base.rb foo.rb bar.rb bing.rb) }
+    allow_any_instance_of(VagrantSpec::Command::Base)
+      .to receive(:instance_variable_get).with('subcommands') { mock_registry }
+  end
+
+  subject { VagrantSpec::Command::Base.new([], iso_env) }
+
+  it 'VagrantSpec::Command::Base is subclass of Vagrant::Plugin::V2:Command' do
+    expect(VagrantSpec::Command::Base).to be < Vagrant::Plugin::V2::Command
+  end
+
+  it 'instance contains the correct valid commands' do
+    expect(subject.valid_commands).to eq(%w(foo bar bing))
+  end
+
+  it '#register_subcommands results in the correct length' do
+    subject.valid_commands.each do |cmd|
+      allow(subject.subcommands).to  receive(:register).with(cmd.to_sym)
+      expect(subject.subcommands).to receive(:register).with(cmd.to_sym)
+    end
+    subject.register_subcommands
+  end
+
+  context 'when -h is passed' do
+    it '#parse_main_args returns help' do
+      i = VagrantSpec::Command::Base.new(%w(-h), iso_env)
+      allow(i).to receive(:help)
+      expect(i).to receive(:help)
+      i.parse_main_args
+    end
+  end
+
+  context 'when --help is passed' do
+    it '#parse_main_args returns help' do
+      i = VagrantSpec::Command::Base.new(%w(--help), iso_env)
+      allow(i).to receive(:help)
+      expect(i).to receive(:help)
+      i.parse_main_args
+    end
+  end
+
+  it '#print_help prints help output' do
+    i = VagrantSpec::Command::Base.new([], iso_env)
+    allow(i).to receive(:instance_variable_get).with('opts') do
+      mock_opts
+    end
+
+    allow(i).to         receive(:help)
+    allow(i.env).to     receive(:ui) { mock_ui }
+    allow(mock_ui).to   receive(:info)
+    allow(mock_opts).to receive(:help)
+
+    expect(i).to        receive(:help)
+    expect(mock_ui).to  receive(:info).with(subject.opts)
+
+    i.print_help
+  end
+
+  context 'when no @sub_commands are nil' do
+    it '#parse_subcommands prints help' do
+      allow(subject).to receive(:instance_variable_get).with('sub_command') do
+        nil
+      end
+      allow(subject.subcommands).to receive(:get) { nil }
+      allow(subject).to  receive(:print_help)
+      expect(subject).to receive(:print_help)
+      subject.parse_subcommand
+    end
+  end
+
+  context 'when @subcommands.get returns nil' do
+    it '#parse_subcommands prints help' do
+      allow(subject).to receive(:instance_variable_get).with('sub_command') do
+        'mock_command'
+      end
+      allow(subject.subcommands).to receive(:get) { nil }
+      allow(subject).to  receive(:print_help)
+      expect(subject).to receive(:print_help)
+      subject.parse_subcommand
+    end
+  end
+
+  it '#execute registers subcommands and parses' do
+    allow(subject).to receive(:register_subcommands)
+    allow(subject).to receive(:parse_main_args)  { 'not_nil' }
+    allow(subject).to receive(:parse_subcommand) { 'not_nil' }
+    expect(subject).to receive(:register_subcommands)
+    expect(subject).to receive(:parse_main_args)
+    expect(subject).to receive(:parse_subcommand)
+    subject.execute
+  end
+end

data/spec/unit/vagrant_spec_test/command_spec/init_spec.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'vagrant_spec/command/init'
+
+describe VagrantSpec::Command::Init do
+  include_context  'unit'
+  include_examples 'shared_mocks'
+
+  let(:mock_spec_helper) do
+    double(VagrantSpec::SpecHelper)
+  end
+
+  let(:mock_ansible_inventory) do
+    double(VagrantSpec::AnsibleInventory)
+  end
+
+  before do
+    allow(mock_spec).to receive(:ansible_inventory) { { 'all' => /node/ } }
+  end
+
+  subject { VagrantSpec::Command::Init.new([], iso_env) }
+
+  it 'VagrantSpec::Command::Init is subclass of Vagrant::Plugin::V2:Command' do
+    expect(VagrantSpec::Command::Init).to be < Vagrant::Plugin::V2::Command
+  end
+
+  def execute_proc
+    proc do
+      allow_any_instance_of(VagrantSpec::SpecHelper).to       receive(:generate)
+      allow_any_instance_of(VagrantSpec::AnsibleInventory).to receive(:generate)
+      allow(mock_spec_helper).to receive(:generate)
+      allow(mock_ansible_inventory).to receive(:generate)
+    end
+  end
+
+  context 'when parse_opts returns nil' do
+    it '#execute does nothing' do
+      allow(subject).to receive(:parse_opts) { nil }
+      execute_proc.call
+      expect(subject.execute).to be_nil
+    end
+  end
+
+  context 'when parse_opts does not return nil' do
+    def execute_protection_proc
+      proc do
+        allow(subject).to receive(:parse_opts) { 'not_nil' }
+        allow(VagrantSpec::SpecHelper).to receive(:new) do
+          mock_spec_helper
+        end
+        allow(VagrantSpec::AnsibleInventory).to receive(:new) do
+          mock_ansible_inventory
+        end
+        execute_proc.call
+      end
+    end
+
+    context 'and when @ansible_inventory eq empty hash,' do
+      it '#execute creates an instance of VagrantSpec::SpecHelper' do
+        execute_protection_proc.call
+        subject.ansible_inventory = {}
+
+        expect(mock_spec_helper).to           receive(:generate)
+        expect(mock_ansible_inventory).to_not receive(:generate)
+        subject.execute
+      end
+    end
+
+    context 'and when @ansible_inventory has data' do
+      it '#execute creates instances of SpecHelper and AnsibleInventory' do
+        execute_protection_proc.call
+        subject.ansible_inventory = { 'all' => /node/ }
+
+        expect(mock_spec_helper).to       receive(:generate)
+        expect(mock_ansible_inventory).to receive(:generate)
+        subject.execute
+      end
+    end
+  end
+
+  it '#parse_opts calls parse_options' do
+    allow(subject).to  receive(:parse_options)
+    expect(subject).to receive(:parse_options)
+    subject.parse_opts
+  end
+end

data/spec/unit/vagrant_spec_test/command_spec/test_spec.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'vagrant_spec/command/test'
+
+describe VagrantSpec::Command::Test do
+  include_context  'unit'
+  include_examples 'shared_mocks'
+
+  let(:mock_test) { double(VagrantSpec::TestPlan) }
+
+  subject { VagrantSpec::Command::Test.new([], iso_env) }
+
+  context 'when parse_opts returns nil' do
+    it '#execute should do nothing' do
+      allow(VagrantSpec::TestPlan).to receive(:new) { mock_test }
+
+      allow(subject).to               receive(:parse_opts) { nil }
+      allow(mock_test).to             receive(:new)
+      allow(mock_test).to             receive(:run)
+
+      expect(mock_test).not_to        receive(:new)
+      subject.execute
+    end
+  end
+
+  context 'when parse_opts returns data' do
+    it '#execute should test' do
+      allow(subject).to               receive(:parse_opts) { 'not_nil' }
+
+      allow(VagrantSpec::TestPlan).to receive(:new) { mock_test }
+      allow(mock_test).to             receive(:new)
+      allow(mock_test).to             receive(:run)
+
+      expect(mock_test).to receive(:run)
+      subject.execute
+    end
+  end
+
+  it '#parse_opts calls parse_options' do
+    allow(subject).to  receive(:parse_options)
+    expect(subject).to receive(:parse_options)
+    subject.parse_opts
+  end
+end

data/spec/unit/vagrant_spec_test/config_spec/base_spec.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'vagrant_spec/config/base'
+require 'vagrant/plugin'
+
+describe VagrantSpec::Config::Base do
+  include_context  'unit'
+  include_examples 'shared_mocks'
+
+  subject { VagrantSpec::Config::Base.new }
+
+  it 'VagrantSpec::Config::Base is a subclass of Vagrant::Plugin::V2::Config' do
+    expect(VagrantSpec::Config::Base).to be < Vagrant::Plugin::V2::Config
+  end
+
+  %i(directory ansible_inventory test_plan).each do |a|
+    it "VagrantSpec::Config::Base has the attr_accessor: #{a}" do
+      expect(subject).to have_attr_accessor(a)
+    end
+  end
+
+  let(:methods) do
+    %w(final_directory final_ansible_inventory final_test_plan)
+  end
+
+  %w(final_directory final_ansible_inventory final_test_plan).each do |method|
+    it "#finalize! calls #{method}" do
+      methods.each { |m| allow(subject).to receive(m.to_sym) }
+      expect(subject).to receive(method.to_sym)
+      subject.finalize!
+    end
+  end
+end