vagrant-hostmaster 0.8.0 → 0.8.1

data/.gitignore

@@ -1,5 +1,8 @@
+.DS_Store
 *.gem
 *.rbc
+*.swo
+*.swp
 .bundle
 .config
 .yardoc

data/README.md

@@ -4,17 +4,9 @@
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Install into vagrant's isolated RubyGems instance using:
 
-    gem 'vagrant-hostmaster'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install vagrant-hostmaster
+    $ vagrant gem install vagrant-hostmaster
 
 ## Usage
 

data/Rakefile

@@ -1,2 +1,11 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/vagrant/hostmaster.rb

@@ -1,4 +1,4 @@
-require 'vagrant/hostmaster/version'
+require 'vagrant'
 require 'vagrant/hostmaster/command/base'
 require 'vagrant/hostmaster/command/root'
 require 'vagrant/hostmaster/config'
@@ -8,7 +8,6 @@ require 'vagrant/hostmaster/middleware/update'
 
 Vagrant.commands.register(:hosts) { Vagrant::Hostmaster::Command::Root }
 Vagrant.config_keys.register(:hosts) { Vagrant::Hostmaster::Config }
-Vagrant.commands.register(:hosts) { Vagrant::Hostmaster::Command::Root }
 
 Vagrant.actions[:destroy].insert_after(Vagrant::Action::VM::ProvisionerCleanup, Vagrant::Hostmaster::Middleware::Remove)
 

data/lib/vagrant/hostmaster/command/base.rb

@@ -14,8 +14,10 @@ module Vagrant
           return if !argv
 
           with_target_vms(argv) do |vm|
-            if vm.created?
+            if vm.state == :running
               Hostmaster::VM.new(vm).send sub_command.to_sym
+            elsif vm.created?
+              vm.ui.info I18n.t("vagrant.commands.common.vm_not_running")
             else
               vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
             end

data/lib/vagrant/hostmaster/middleware/remove.rb

@@ -7,7 +7,7 @@ module Vagrant
         end
 
         def call(env)
-          remove env[:vm]
+          remove env[:vm] if env["vm"].created?
           @app.call(env)
         end
 

data/lib/vagrant/hostmaster/middleware/update.rb

@@ -8,7 +8,7 @@ module Vagrant
 
         def call(env)
           @app.call(env)
-          update env[:vm]
+          update env[:vm] if env["vm"].state == :running
         end
 
         protected

data/lib/vagrant/hostmaster/version.rb

@@ -1,5 +1,5 @@
 module Vagrant
   module Hostmaster
-    VERSION = "0.8.0"
+    VERSION = "0.8.1"
   end
 end

data/lib/vagrant/hostmaster/vm.rb

@@ -7,6 +7,12 @@ module Vagrant
 
       def_delegators :@vm, :channel, :config, :env, :name, :uuid
 
+      class << self
+        def hosts_path
+          Util::Platform.windows? ? "#{ENV['SYSTEMROOT']}/system32/drivers/etc/hosts" : "/etc/hosts"
+        end
+      end
+
       def initialize(vm)
         @vm = vm
       end
@@ -17,26 +23,29 @@ module Vagrant
           sudo add_command
         end
 
-        with_other_vms { |vm| channel.sudo vm.add_command(uuid) } if process_guests?(options)
+        with_other_vms { |vm| channel.sudo vm.add_command(:uuid => uuid, :hosts_path => hosts_path) } if process_guests?(options)
+      end
+
+      def hosts_path
+        # TODO: if windows guests are supported, this will need to be smarter
+        "/etc/hosts"
       end
 
       def list(options = {})
         if process_local?(options)
           output = `#{list_command}`.chomp
-          env.ui.info("Local host entry for #{name}...\n#{output}\n\n", :prefix => false) unless output.empty?
+          env.ui.info("[local] #{output}\n\n", :prefix => false) unless output.empty?
         end
 
         if process_guests?(options)
-          entries = []
+          entries = ""
           with_other_vms do |vm|
-            entry = ""
-            channel.execute(vm.list_command(uuid), :error_check => false) do |type, data|
-              entry << data if type == :stdout
+            channel.execute(vm.list_command(:uuid => uuid, :hosts_path => hosts_path), :error_check => false) do |type, data|
+              entries << data if type == :stdout
             end
-            entry.chomp!
-            entries << entry unless entry.empty?
           end
-          env.ui.info("Guest host #{entries.size > 1 ? 'entries' : 'entry'} on #{name}...\n#{entries.join("\n")}\n\n", :prefix => false) unless entries.empty?
+          entries = entries.split($/).collect { |entry| "[#{name}] #{entry}" }.join("\n")
+          env.ui.info("#{entries}\n\n", :prefix => false) unless entries.empty?
         end
       end
 
@@ -45,7 +54,7 @@ module Vagrant
           env.ui.info("Removing host entry for #{name} VM. Administrator privileges will be required...") unless options[:quiet]
           sudo remove_command
         end
-        with_other_vms { |vm| channel.sudo vm.remove_command(uuid) } if process_guests?(options)
+        with_other_vms { |vm| channel.sudo vm.remove_command(:uuid => uuid, :hosts_path => hosts_path) } if process_guests?(options)
       end
 
       def update(options = {})
@@ -53,12 +62,14 @@ module Vagrant
           env.ui.info("Updating host entry for #{name} VM. Administrator privileges will be required...") unless options[:quiet]
           sudo(remove_command) && sudo(add_command)
         end
-        with_other_vms { |vm| channel.sudo(vm.remove_command(uuid)) && channel.sudo(vm.add_command(uuid)) } if process_guests?(options)
+        with_other_vms { |vm| channel.sudo(vm.remove_command(:uuid => uuid, :hosts_path => hosts_path)) && channel.sudo(vm.add_command(:uuid => uuid, :hosts_path => hosts_path)) } if process_guests?(options)
       end
 
       protected
-        def add_command(uuid = self.uuid)
-          %Q(sh -c 'echo "#{host_entry(uuid)}" >>/etc/hosts')
+        def add_command(options = {})
+          uuid = options[:uuid] || self.uuid
+          hosts_path = options[:hosts_path] || self.class.hosts_path
+          %Q(sh -c 'echo "#{host_entry(uuid)}" >>#{hosts_path}')
         end
 
         def address
@@ -90,8 +101,10 @@ module Vagrant
           {:local => true}.merge(options)[:local]
         end
 
-        def list_command(uuid = self.uuid)
-          %Q(grep '#{signature(uuid)}$' /etc/hosts)
+        def list_command(options = {})
+          uuid = options[:uuid] || self.uuid
+          hosts_path = options[:hosts_path] || self.class.hosts_path
+          %Q(grep '#{signature(uuid)}$' #{hosts_path})
         end
 
         def network
@@ -108,8 +121,10 @@ module Vagrant
           @networks ||= config.vm.networks
         end
 
-        def remove_command(uuid = self.uuid)
-          %Q(sed -e '/#{signature(uuid)}$/ d' -ibak /etc/hosts)
+        def remove_command(options = {})
+          uuid = options[:uuid] || self.uuid
+          hosts_path = options[:hosts_path] || self.class.hosts_path
+          %Q(sed -e '/#{signature(uuid)}$/ d' -ibak #{hosts_path})
         end
 
         def signature(uuid = self.uuid)
@@ -117,7 +132,11 @@ module Vagrant
         end
 
         def sudo(command)
-          `sudo #{command}`
+          if Util::Platform.windows?
+            `#{command}`
+          else
+            `sudo #{command}`
+          end
         end
 
         def with_other_vms

data/test/vagrant/hostmaster/command_tests/list_test.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'mocha'
+require 'vagrant/hostmaster'
+require 'vagrant/hostmaster/command/list'
+
+module Vagrant
+  module Hostmaster
+    module CommandTests
+      class ListTest < Test::Unit::TestCase
+        include Vagrant::TestHelpers
+
+        def setup
+          @env = vagrant_env
+          @vm = @env.vms.values.first
+          @vm.stubs(:state).returns(:running)
+          @command = Vagrant::Hostmaster::Command::List.new([], @env)
+        end
+
+        def test_not_created
+          @vm.stubs(:state).returns(:not_created)
+          Vagrant::Hostmaster::Command::List.expects(:new).with([], @env).returns(@command)
+          Vagrant::Hostmaster::VM.expects(:new).never
+          @env.cli('hosts', 'list')
+        end
+
+        def test_not_running
+          @vm.stubs(:state).returns(:poweroff)
+          Vagrant::Hostmaster::Command::List.expects(:new).with([], @env).returns(@command)
+          Vagrant::Hostmaster::VM.expects(:new).never
+          @env.cli('hosts', 'list')
+        end
+
+        def test_list
+          Vagrant::Hostmaster::Command::List.stubs(:new).with([], @env).returns(@command)
+          vm = Vagrant::Hostmaster::VM.new(@vm)
+          Vagrant::Hostmaster::VM.expects(:new).with(@vm).returns(vm)
+          vm.expects(:list).with()
+          @env.cli('hosts', 'list')
+        end
+      end
+    end
+  end
+end

data/test/vagrant/hostmaster/command_tests/remove_test.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'mocha'
+require 'vagrant/hostmaster'
+require 'vagrant/hostmaster/command/remove'
+
+module Vagrant
+  module Hostmaster
+    module CommandTests
+      class RemoveTest < Test::Unit::TestCase
+        include Vagrant::TestHelpers
+
+        def setup
+          @env = vagrant_env
+          @vm = @env.vms.values.first
+          @vm.stubs(:state).returns(:running)
+          @command = Vagrant::Hostmaster::Command::Remove.new([], @env)
+        end
+
+        def test_not_created
+          @vm.stubs(:state).returns(:not_created)
+          Vagrant::Hostmaster::Command::Remove.expects(:new).with([], @env).returns(@command)
+          Vagrant::Hostmaster::VM.expects(:new).never
+          @env.cli('hosts', 'remove')
+        end
+
+        def test_not_running
+          @vm.stubs(:state).returns(:poweroff)
+          Vagrant::Hostmaster::Command::Remove.expects(:new).with([], @env).returns(@command)
+          Vagrant::Hostmaster::VM.expects(:new).never
+          @env.cli('hosts', 'remove')
+        end
+
+        def test_remove
+          Vagrant::Hostmaster::Command::Remove.stubs(:new).with([], @env).returns(@command)
+          vm = Vagrant::Hostmaster::VM.new(@vm)
+          Vagrant::Hostmaster::VM.expects(:new).with(@vm).returns(vm)
+          vm.expects(:remove).with()
+          @env.cli('hosts', 'remove')
+        end
+      end
+    end
+  end
+end

data/test/vagrant/hostmaster/command_tests/root_test.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'mocha'
+require 'vagrant/hostmaster'
+require 'vagrant/hostmaster/command/list'
+require 'vagrant/hostmaster/command/remove'
+require 'vagrant/hostmaster/command/update'
+
+module Vagrant
+  module Hostmaster
+    module CommandTests
+      class RootTest < Test::Unit::TestCase
+        include Vagrant::TestHelpers
+
+        def setup
+          @env = vagrant_env
+          @vm = @env.vms.values.first
+        end
+
+        def test_no_command
+          command = Vagrant::Hostmaster::Command::Root.new([], @env)
+          Vagrant::Hostmaster::Command::Root.expects(:new).with([], @env).returns(command)
+          command.expects(:help)
+          @env.cli('hosts')
+        end
+
+        def test_list
+          command = Vagrant::Hostmaster::Command::List.new([], @env)
+          Vagrant::Hostmaster::Command::List.expects(:new).with([], @env).returns(command)
+          command.expects(:execute).with()
+          @env.cli('hosts', 'list')
+        end
+
+        def test_remove
+          command = Vagrant::Hostmaster::Command::Remove.new([], @env)
+          Vagrant::Hostmaster::Command::Remove.expects(:new).with([], @env).returns(command)
+          command.expects(:execute).with()
+          @env.cli('hosts', 'remove')
+        end
+
+        def test_update
+          command = Vagrant::Hostmaster::Command::Update.new([], @env)
+          Vagrant::Hostmaster::Command::Update.expects(:new).with([], @env).returns(command)
+          command.expects(:execute).with()
+          @env.cli('hosts', 'update')
+        end
+      end
+    end
+  end
+end

data/test/vagrant/hostmaster/command_tests/update_test.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'mocha'
+require 'vagrant/hostmaster'
+require 'vagrant/hostmaster/command/update'
+
+module Vagrant
+  module Hostmaster
+    module CommandTests
+      class UpdateTest < Test::Unit::TestCase
+        include Vagrant::TestHelpers
+
+        def setup
+          @env = vagrant_env
+          @vm = @env.vms.values.first
+          @vm.stubs(:state).returns(:running)
+          @command = Vagrant::Hostmaster::Command::Update.new([], @env)
+        end
+
+        def test_not_created
+          @vm.stubs(:state).returns(:not_created)
+          Vagrant::Hostmaster::Command::Update.expects(:new).with([], @env).returns(@command)
+          Vagrant::Hostmaster::VM.expects(:new).never
+          @env.cli('hosts', 'update')
+        end
+
+        def test_not_running
+          @vm.stubs(:state).returns(:poweroff)
+          Vagrant::Hostmaster::Command::Update.expects(:new).with([], @env).returns(@command)
+          Vagrant::Hostmaster::VM.expects(:new).never
+          @env.cli('hosts', 'update')
+        end
+
+        def test_update
+          Vagrant::Hostmaster::Command::Update.stubs(:new).with([], @env).returns(@command)
+          vm = Vagrant::Hostmaster::VM.new(@vm)
+          Vagrant::Hostmaster::VM.expects(:new).with(@vm).returns(vm)
+          vm.expects(:update).with()
+          @env.cli('hosts', 'update')
+        end
+      end
+    end
+  end
+end

data/test/vagrant/hostmaster/config_test.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require "mocha"
+require 'vagrant/hostmaster'
+
+module Vagrant
+  module Hostmaster
+    class ConfigTest < Test::Unit::TestCase
+      include Vagrant::TestHelpers
+
+      def setup
+        @config = Vagrant::Hostmaster::Config.new
+        @errors = Vagrant::Config::ErrorRecorder.new
+        @env = vagrant_env
+      end
+
+      def test_default_valid
+        @config.validate(@env, @errors)
+        assert @errors.errors.empty?, "Default configuration should not have any errors."
+      end
+
+      def test_valid
+        @config.name = 'hostmaster.dev'
+        @config.aliases = %w(www.hostmaster.dev)
+        @config.validate(@env, @errors)
+        assert @errors.errors.empty?, "Configuration should not have any errors."
+      end
+    end
+  end
+end

data/test/vagrant/hostmaster/middleware_tests/remove_test.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require "mocha"
+require 'vagrant/hostmaster'
+
+module Vagrant
+  module Hostmaster
+    module MiddlewareTests
+      class RemoveTest < Test::Unit::TestCase
+        include Vagrant::TestHelpers
+
+        def setup
+          @app, @env = action_env(vagrant_env.vms.values.first.env)
+          @env['vm'].stubs(:state).returns(:running)
+          @middleware = Vagrant::Hostmaster::Middleware::Remove.new(@app, @env)
+        end
+
+        def test_not_created
+          @env['vm'].stubs(:state).returns(:not_created)
+          Vagrant::Hostmaster::VM.expects(:new).never
+          @middleware.call(@env)
+        end
+
+        def test_not_running
+          @env['vm'].stubs(:state).returns(:poweroff)
+          vm = Vagrant::Hostmaster::VM.new(@env['vm'])
+          Vagrant::Hostmaster::VM.expects(:new).with(@env['vm']).returns(vm)
+          vm.expects(:remove).with(:guests => false)
+          @middleware.call(@env)
+        end
+
+        def test_remove
+          vm = Vagrant::Hostmaster::VM.new(@env['vm'])
+          Vagrant::Hostmaster::VM.expects(:new).with(@env['vm']).returns(vm)
+          vm.expects(:remove).with(:guests => false)
+          @middleware.call(@env)
+        end
+      end
+    end
+  end
+end

data/test/vagrant/hostmaster/middleware_tests/update_test.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require "mocha"
+require 'vagrant/hostmaster'
+
+module Vagrant
+  module Hostmaster
+    module MiddlewareTests
+      class UpdateTest < Test::Unit::TestCase
+        include Vagrant::TestHelpers
+
+        def setup
+          @app, @env = action_env(vagrant_env.vms.values.first.env)
+          @env['vm'].stubs(:state).returns(:running)
+          @middleware = Vagrant::Hostmaster::Middleware::Update.new(@app, @env)
+        end
+
+        def test_not_created
+          @env['vm'].stubs(:state).returns(:not_created)
+          Vagrant::Hostmaster::VM.expects(:new).never
+          @middleware.call(@env)
+        end
+
+        def test_not_running
+          @env['vm'].stubs(:state).returns(:poweroff)
+          Vagrant::Hostmaster::VM.expects(:new).never
+          @middleware.call(@env)
+        end
+
+        def test_update
+          vm = Vagrant::Hostmaster::VM.new(@env['vm'])
+          Vagrant::Hostmaster::VM.expects(:new).with(@env['vm']).returns(vm)
+          vm.expects(:update).with()
+          @middleware.call(@env)
+        end
+      end
+    end
+  end
+end

data/test/vagrant/hostmaster/multiple_vm_test.rb

@@ -0,0 +1,88 @@
+require 'test/unit'
+require "mocha"
+require 'vagrant/hostmaster'
+require 'vagrant/hostmaster/test_helpers'
+
+module Vagrant
+  module Hostmaster
+    class MultipleVMTest < Test::Unit::TestCase
+      include Vagrant::TestHelpers
+      include Vagrant::Hostmaster::TestHelpers
+
+      def setup
+        super
+
+        # TODO: test both windows and non-windows
+        Util::Platform.stubs(:windows?).returns(false)
+        @hosts_file = Tempfile.new('hosts')
+        hostmaster_box :one, 'one.hostmaster.dev', '10.0.0.100', '11111111-1111-1111-1111-111111111111'
+        hostmaster_box :two, 'two.hostmaster.dev', '10.0.0.200', '22222222-2222-2222-2222-222222222222'
+        @vms = hostmaster_vms(hostmaster_env)
+      end
+
+      def teardown
+        @hosts_file.unlink
+        clean_paths
+        super
+      end
+
+      def test_add
+        Vagrant::Hostmaster::VM.stubs(:hosts_path).returns @hosts_file.path
+        @vms.each do |vm|
+          hostmaster_boxes.each do |name,box|
+            next if name == vm.name
+            param = %Q(sh -c 'echo \"#{box[:address]}  #{box[:host_name]}  # VAGRANT: #{vm.uuid} \(#{name}\)\" >>#{vm.hosts_path}')
+            vm.channel.expects(:sudo).with(param)
+          end
+          vm.add
+        end
+        assert_local_host_entries_for @vms, @hosts_file
+      end
+
+      def test_list
+        Vagrant::Hostmaster::VM.stubs(:hosts_path).returns @hosts_file.path
+        write_local_host_entries @hosts_file
+        hostmaster_boxes.each do |target_name,target_box|
+          address, host_name, uuid, vm = target_box.values_at(:address, :host_name, :uuid, :vm)
+          hostmaster_boxes.each do |name,box|
+            next if name == target_name
+            param = "grep '# VAGRANT: #{uuid} (#{name})$' #{vm.hosts_path}"
+            vm.channel.expects(:execute).with(param, :error_check => false)
+          end
+          output = Vagrant::Hostmaster::UI::Capture.capture { vm.list }
+          assert_match /^\[local\] #{address} #{host_name} # VAGRANT: #{uuid} \(#{target_name}\)$/, output
+        end
+      end
+
+      def test_remove_local_hosts_entry
+        Vagrant::Hostmaster::VM.stubs(:hosts_path).returns @hosts_file.path
+        write_local_host_entries @hosts_file
+        @vms.each do |vm|
+          hostmaster_boxes.each do |name,box|
+            next if name == vm.name
+            param = %Q(sed -e '/# VAGRANT: #{vm.uuid} (#{name})$/ d' -ibak #{vm.hosts_path})
+            vm.channel.expects(:sudo).with(param)
+          end
+          vm.remove
+        end
+        assert_no_local_host_entries_for @vms, @hosts_file
+      end
+
+      def test_update_local_hosts_entry
+        Vagrant::Hostmaster::VM.stubs(:hosts_path).returns @hosts_file.path
+        write_local_host_entries @hosts_file, :one => {:address => '10.10.10.11', :host_name => 'a.hostmaster.dev'}, :two => {:address => '10.10.10.22', :host_name => 'b.hostmaster.dev'}
+        @vms.each do |vm|
+          hostmaster_boxes.each do |name,box|
+            next if name == vm.name
+            param = %Q(sed -e '/# VAGRANT: #{vm.uuid} (#{name})$/ d' -ibak #{vm.hosts_path})
+            vm.channel.expects(:sudo).with(param).returns(0)
+            param = %Q(sh -c 'echo \"#{box[:address]}  #{box[:host_name]}  # VAGRANT: #{vm.uuid} \(#{name}\)\" >>#{vm.hosts_path}')
+            vm.channel.expects(:sudo).with(param).returns(0)
+          end
+          vm.update
+        end
+        assert_local_host_entries_for @vms, @hosts_file
+      end
+    end
+  end
+end

data/test/vagrant/hostmaster/simple_vm_test.rb

@@ -0,0 +1,77 @@
+require 'test/unit'
+require "mocha"
+require 'vagrant/hostmaster'
+require 'vagrant/hostmaster/test_helpers'
+
+module Vagrant
+  module Hostmaster
+    class SimpleVMTest < Test::Unit::TestCase
+      include Vagrant::TestHelpers
+      include Vagrant::Hostmaster::TestHelpers
+
+      def setup
+        super
+
+        # TODO: test both windows and non-windows
+        Util::Platform.stubs(:windows?).returns(false)
+        @hosts_file = Tempfile.new('hosts')
+        hostmaster_box :default, 'hostmaster.dev', '123.45.67.89', '01234567-89ab-cdef-fedc-ba9876543210'
+        @vms = hostmaster_vms(hostmaster_env)
+      end
+
+      def teardown
+        @hosts_file.unlink
+        clean_paths
+        super
+      end
+
+      def test_hosts_path
+        assert_equal '/etc/hosts', Vagrant::Hostmaster::VM.hosts_path
+      end
+
+      def test_hosts_path_on_windows
+        Util::Platform.stubs(:windows?).returns(true)
+        ENV.stubs(:[]).with('SYSTEMROOT').returns('/windows')
+        assert_equal '/windows/system32/drivers/etc/hosts', Vagrant::Hostmaster::VM.hosts_path
+      end
+
+      def test_vm_hosts_path
+        assert_equal '/etc/hosts', @vms.first.hosts_path
+      end
+
+      def test_hosts_path_on_windows
+        Util::Platform.stubs(:windows?).returns(true)
+        assert_equal '/etc/hosts', @vms.first.hosts_path
+      end
+
+      def test_add_local_hosts_entry
+        Vagrant::Hostmaster::VM.stubs(:hosts_path).returns @hosts_file.path
+        @vms.each { |vm| vm.add }
+        assert_local_host_entries_for @vms, @hosts_file
+      end
+
+      def test_list_local_hosts_entry
+        Vagrant::Hostmaster::VM.stubs(:hosts_path).returns @hosts_file.path
+        write_local_host_entries @hosts_file
+        hostmaster_boxes.each do |name,box|
+          output = Vagrant::Hostmaster::UI::Capture.capture { box[:vm].list }
+          assert_match /^\[local\]\s+#{box[:address]}\s+#{box[:host_name]}\s*# VAGRANT: #{box[:uuid]} \(#{name}\)$/, output
+        end
+      end
+
+      def test_remove_local_hosts_entry
+        Vagrant::Hostmaster::VM.stubs(:hosts_path).returns @hosts_file.path
+        write_local_host_entries @hosts_file
+        @vms.each { |vm| vm.remove }
+        assert_no_local_host_entries_for @vms, @hosts_file
+      end
+
+      def test_update
+        Vagrant::Hostmaster::VM.stubs(:hosts_path).returns @hosts_file.path
+        write_local_host_entries @hosts_file, :default => {:address => '10.10.10.10', :host_name => 'www.hostmaster.dev'}
+        @vms.each { |vm| vm.update }
+        assert_local_host_entries_for @vms, @hosts_file
+      end
+    end
+  end
+end

data/test/vagrant/hostmaster/test_helpers.rb

@@ -0,0 +1,137 @@
+require 'generator'
+require 'vagrant/hostmaster/ui/capture'
+
+module Vagrant
+  module Hostmaster
+    module TestHelpers
+      protected
+        def assert_local_host_address_of(address, vm, hosts_file, message=nil)
+          _wrap_assertion do
+            hosts_file.open
+            full_message = build_message(message,
+                                          "Expected host address of ? for ?.\n?",
+                                          address,
+                                          vm.uuid,
+                                          hosts_file.read
+                                        )
+            hosts_file.rewind
+            assert_block(full_message) do
+              hosts_file.grep(/# VAGRANT: #{vm.uuid} \(#{vm.name}\)$/).any? do |entry|
+                scanner = StringScanner.new(entry.chomp)
+                scanner.skip(/\s+/)
+                scanner.scan(/[0-9.]+/) == address
+              end
+            end
+          end
+        end
+
+        def assert_local_host_entries_for(vms, hosts_file)
+          hostmaster_boxes.each do |name,box|
+            assert_local_host_entry_for box[:vm], hosts_file
+            assert_local_host_address_of box[:address], box[:vm], hosts_file
+            assert_local_host_name_of box[:host_name], box[:vm], hosts_file
+          end
+        end
+
+        def assert_local_host_entry_for(vm, hosts_file, message=nil)
+          _wrap_assertion do
+            hosts_file.open
+            full_message = build_message(message,
+                                          "Expected host entry for ? to exist.\n?",
+                                          vm.uuid,
+                                          hosts_file.read
+                                        )
+            hosts_file.rewind
+            assert_block(full_message) do
+              hosts_file.grep(/# VAGRANT: #{vm.uuid} \(#{vm.name}\)$/).any?
+            end
+          end
+        end
+
+        def assert_local_host_name_of(name, vm, hosts_file, message=nil)
+          _wrap_assertion do
+            hosts_file.open
+            full_message = build_message(message,
+                                          "Expected host name of ? for ?.\n?",
+                                          name,
+                                          vm.uuid,
+                                          hosts_file.read
+                                        )
+            hosts_file.rewind
+            assert_block(full_message) do
+              hosts_file.grep(/# VAGRANT: #{vm.uuid} \(#{vm.name}\)$/).any? do |entry|
+                scanner = StringScanner.new(entry.chomp)
+                scanner.skip(/\s+/)
+                scanner.skip(/[0-9.]+/)
+                scanner.skip(/\s+/)
+                scanner.scan(/[^\s#]+/) == name
+              end
+            end
+          end
+        end
+
+        def assert_no_local_host_entries_for(vms, hosts_file)
+          vms.each do |vm|
+            assert_no_local_host_entry_for(vm, hosts_file)
+          end
+        end
+
+        def assert_no_local_host_entry_for(vm, hosts_file, message=nil)
+          _wrap_assertion do
+            hosts_file.open
+            full_message = build_message(message,
+                                          "Expected host entry for ? to not exist.\n?",
+                                          vm.uuid,
+                                          hosts_file.read
+                                        )
+            hosts_file.rewind
+            assert_block(full_message) do
+              hosts_file.grep(/# VAGRANT: #{vm.uuid} \(#{vm.name}\)$/).empty?
+            end
+          end
+        end
+
+        def hostmaster_box(name, host_name, address, uuid)
+          hostmaster_boxes[name] = {:name => name, :host_name => host_name, :address => address, :uuid => uuid}
+          hostmaster_boxes
+        end
+
+        def hostmaster_boxes
+          @boxes ||= {}
+        end
+
+        def hostmaster_config
+          hostmaster_boxes.inject("") do |config,(name,box)|
+            config << <<-EOF
+              config.vm.define :#{name} do |box|
+                box.vm.host_name = "#{box[:host_name]}"
+                box.vm.network :hostonly, "#{box[:address]}"
+              end
+            EOF
+          end
+        end
+
+        def hostmaster_env
+          Vagrant::Environment.new(:cwd => vagrantfile(hostmaster_config), :ui_class => Vagrant::Hostmaster::UI::Capture).load!
+        end
+
+        def hostmaster_vms(env)
+          env.vms.values.collect do |vm|
+            box = hostmaster_boxes[vm.name]
+            vm.stubs(:state).returns(:running)
+            vm.stubs(:uuid).returns(box[:uuid])
+            box[:vm] = Vagrant::Hostmaster::VM.new(vm)
+          end
+        end
+
+        def write_local_host_entries(hosts_file, entries={})
+          hostmaster_boxes.each do |name,box|
+            entry = box.merge(entries[name] || {})
+            hosts_file.puts "#{entry[:address]} #{entry[:host_name]} # VAGRANT: #{entry[:uuid]} (#{entry[:name]})"
+          end
+          hosts_file.fsync
+          hosts_file
+        end
+    end
+  end
+end

data/test/vagrant/hostmaster/ui/capture.rb

@@ -0,0 +1,35 @@
+module Vagrant
+  module Hostmaster
+    module UI
+      class Capture < Vagrant::UI::Silent
+        class << self
+          def capture
+            return @capture unless block_given?
+            begin
+              current, @capture = @capture, ""
+              yield
+              result = @capture
+            ensure
+              @capture = current
+            end
+          end
+
+          def capture?
+            @capture
+          end
+        end
+        [:info, :warn, :error, :success].each do |method|
+          class_eval <<-CODE
+            def #{method}(message, *args)
+              super(message)
+              if self.class.capture?
+                self.class.capture << message
+                self.class.capture << "\n" unless message[-1,1] == "\n"
+              end
+            end
+          CODE
+        end
+      end
+    end
+  end
+end

data/vagrant-hostmaster.gemspec

@@ -15,6 +15,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Vagrant::Hostmaster::VERSION
 
-  gem.add_dependency('vagrant', '~>1.0.3')
-  gem.add_development_dependency('rake')
+  gem.add_dependency  'vagrant', '~>1.0.3'
+  gem.add_development_dependency  'bundler'
+  gem.add_development_dependency  'mocha', '~>0.12.3'
+  gem.add_development_dependency  'rake'
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 8
-  - 0
-  version: 0.8.0
+  - 1
+  version: 0.8.1
 platform: ruby
 authors: 
 - S. Brent Faulkner
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-19 00:00:00 -04:00
+date: 2012-08-29 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,9 +40,35 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  name: rake
+  name: bundler
   requirement: *id002
   prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 12
+        - 3
+        version: 0.12.3
+  name: mocha
+  requirement: *id003
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  name: rake
+  requirement: *id004
+  prerelease: false
 description: vagrant-hostmaster is a Vagrant plugin to manage /etc/hosts entries on both the host OS and guest VMs.
 email: 
 - brent.faulkner@mosaic.com
@@ -70,6 +96,17 @@ files:
 - lib/vagrant/hostmaster/version.rb
 - lib/vagrant/hostmaster/vm.rb
 - lib/vagrant_init.rb
+- test/vagrant/hostmaster/command_tests/list_test.rb
+- test/vagrant/hostmaster/command_tests/remove_test.rb
+- test/vagrant/hostmaster/command_tests/root_test.rb
+- test/vagrant/hostmaster/command_tests/update_test.rb
+- test/vagrant/hostmaster/config_test.rb
+- test/vagrant/hostmaster/middleware_tests/remove_test.rb
+- test/vagrant/hostmaster/middleware_tests/update_test.rb
+- test/vagrant/hostmaster/multiple_vm_test.rb
+- test/vagrant/hostmaster/simple_vm_test.rb
+- test/vagrant/hostmaster/test_helpers.rb
+- test/vagrant/hostmaster/ui/capture.rb
 - vagrant-hostmaster.gemspec
 has_rdoc: true
 homepage: https://github.com/mosaicxm/vagrant-hostmaster
@@ -101,5 +138,15 @@ rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Vagrant plugin to manage /etc/hosts entries.
-test_files: []
-
+test_files: 
+- test/vagrant/hostmaster/command_tests/list_test.rb
+- test/vagrant/hostmaster/command_tests/remove_test.rb
+- test/vagrant/hostmaster/command_tests/root_test.rb
+- test/vagrant/hostmaster/command_tests/update_test.rb
+- test/vagrant/hostmaster/config_test.rb
+- test/vagrant/hostmaster/middleware_tests/remove_test.rb
+- test/vagrant/hostmaster/middleware_tests/update_test.rb
+- test/vagrant/hostmaster/multiple_vm_test.rb
+- test/vagrant/hostmaster/simple_vm_test.rb
+- test/vagrant/hostmaster/test_helpers.rb
+- test/vagrant/hostmaster/ui/capture.rb