vagrantup 0.1.0

data/test/vagrant/actions/vm/provision_test.rb

@@ -0,0 +1,103 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ProvisionActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Provision)
+
+    Vagrant::SSH.stubs(:execute)
+    Vagrant::SSH.stubs(:upload!)
+
+    mock_config
+  end
+
+  context "shared folders" do
+    should "setup shared folder on VM for the cookbooks" do
+      File.expects(:expand_path).with(Vagrant.config.chef.cookbooks_path, Vagrant::Env.root_path).returns("foo")
+      @action.expects(:cookbooks_path).returns("bar")
+      assert_equal ["vagrant-provisioning", "foo", "bar"], @action.collect_shared_folders
+    end
+  end
+
+  context "cookbooks path" do
+    should "return the proper cookbook path" do
+      cookbooks_path = File.join(Vagrant.config.chef.provisioning_path, "cookbooks")
+      assert_equal cookbooks_path, @action.cookbooks_path
+    end
+  end
+
+  context "permissions on provisioning folder" do
+    should "chown the folder to the ssh user" do
+      ssh = mock("ssh")
+      ssh.expects(:exec!).with("sudo chown #{Vagrant.config.ssh.username} #{Vagrant.config.chef.provisioning_path}")
+      Vagrant::SSH.expects(:execute).yields(ssh)
+      @action.chown_provisioning_folder
+    end
+  end
+
+  context "generating and uploading json" do
+    def assert_json
+      Vagrant::SSH.expects(:upload!).with do |json, path|
+        data = JSON.parse(json.read)
+        yield data
+        true
+      end
+
+      @action.setup_json
+    end
+
+    should "merge in the extra json specified in the config" do
+      Vagrant.config.chef.json = { :foo => "BAR" }
+      assert_json do |data|
+        assert_equal "BAR", data["foo"]
+      end
+    end
+
+    should "add the directory as a special case to the JSON" do
+      assert_json do |data|
+        assert_equal Vagrant.config.vm.project_directory, data["vagrant"]["directory"]
+      end
+    end
+
+    should "add the config to the JSON" do
+      assert_json do |data|
+        assert_equal Vagrant.config.vm.project_directory, data["vagrant"]["config"]["vm"]["project_directory"]
+      end
+    end
+
+    should "upload a StringIO to dna.json" do
+      StringIO.expects(:new).with(anything).returns("bar")
+      File.expects(:join).with(Vagrant.config.chef.provisioning_path, "dna.json").once.returns("baz")
+      Vagrant::SSH.expects(:upload!).with("bar", "baz").once
+      @action.setup_json
+    end
+  end
+
+  context "generating and uploading chef solo configuration file" do
+    should "upload properly generate the configuration file using configuration data" do
+      expected_config = <<-config
+file_cache_path "#{Vagrant.config.chef.provisioning_path}"
+cookbook_path "#{@action.cookbooks_path}"
+config
+
+      StringIO.expects(:new).with(expected_config).once
+      @action.setup_solo_config
+    end
+
+    should "upload this file as solo.rb to the provisioning folder" do
+      @action.expects(:cookbooks_path).returns("cookbooks")
+      StringIO.expects(:new).returns("foo")
+      File.expects(:join).with(Vagrant.config.chef.provisioning_path, "solo.rb").once.returns("bar")
+      Vagrant::SSH.expects(:upload!).with("foo", "bar").once
+      @action.setup_solo_config
+    end
+  end
+
+  context "running chef solo" do
+    should "cd into the provisioning directory and run chef solo" do
+      ssh = mock("ssh")
+      ssh.expects(:exec!).with("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json").once
+      Vagrant::SSH.expects(:execute).yields(ssh)
+      @action.run_chef_solo
+    end
+  end
+end

data/test/vagrant/actions/vm/reload_test.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ReloadActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Reload)
+    mock_config
+  end
+
+  context "sub-actions" do
+    setup do
+      @default_order = [Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Start]
+      @vm.stubs(:running?).returns(false)
+    end
+
+    def setup_action_expectations
+      default_seq = sequence("default_seq")
+      @default_order.each do |action|
+        @runner.expects(:add_action).with(action).once.in_sequence(default_seq)
+      end
+    end
+
+    should "do the proper actions by default" do
+      setup_action_expectations
+      @action.prepare
+    end
+
+    should "halt if the VM is running" do
+      @vm.expects(:running?).returns(true)
+      @default_order.unshift(Vagrant::Actions::VM::Halt)
+      setup_action_expectations
+      @action.prepare
+    end
+
+    should "add in the provisioning step if enabled" do
+      mock_config do |config|
+        config.chef.enabled = true
+      end
+
+      @default_order.push(Vagrant::Actions::VM::Provision)
+      setup_action_expectations
+      @action.prepare
+    end
+  end
+end

data/test/vagrant/actions/vm/resume_test.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ResumeActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Resume)
+    mock_config
+  end
+
+  context "executing" do
+    setup do
+      @vm.stubs(:saved?).returns(true)
+    end
+
+    should "save the state of the VM" do
+      @runner.expects(:start).once
+      @action.execute!
+    end
+
+    should "raise an ActionException if the VM is not saved" do
+      @vm.expects(:saved?).returns(false)
+      @vm.expects(:start).never
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.execute!
+      }
+    end
+  end
+end

data/test/vagrant/actions/vm/shared_folders_test.rb

@@ -0,0 +1,117 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class SharedFoldersActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::SharedFolders)
+    mock_config
+  end
+
+  def stub_shared_folders
+    folders = [%w{foo from to}, %w{bar bfrom bto}]
+    @action.expects(:shared_folders).returns(folders)
+    folders
+  end
+
+  context "collecting shared folders" do
+    should "return the arrays that the callback returns" do
+      result = [[1,2,3],[4,5,6]]
+      @mock_vm.expects(:invoke_callback).with(:collect_shared_folders).once.returns(result)
+      assert_equal result, @action.shared_folders
+    end
+
+    should "filter out invalid results" do
+      result = [[1,2,3],[4,5]]
+      @mock_vm.expects(:invoke_callback).with(:collect_shared_folders).once.returns(result)
+      assert_equal [[1,2,3]], @action.shared_folders
+    end
+  end
+
+  context "setting up shared folder metadata" do
+    setup do
+      @folders = stub_shared_folders
+    end
+
+    should "add all shared folders to the VM" do
+      share_seq = sequence("share_seq")
+      shared_folders = mock("shared_folders")
+      shared_folders.expects(:<<).in_sequence(share_seq).with() { |sf| sf.name == "foo" && sf.hostpath == "from" }
+      shared_folders.expects(:<<).in_sequence(share_seq).with() { |sf| sf.name == "bar" && sf.hostpath == "bfrom" }
+      @vm.stubs(:shared_folders).returns(shared_folders)
+      @vm.expects(:save).with(true).once
+
+      @action.before_boot
+    end
+  end
+
+  context "mounting the shared folders" do
+    setup do
+      @folders = stub_shared_folders
+    end
+
+    should "mount all shared folders to the VM" do
+      mount_seq = sequence("mount_seq")
+      ssh = mock("ssh")
+      @folders.each do |name, hostpath, guestpath|
+        ssh.expects(:exec!).with("sudo mkdir -p #{guestpath}").in_sequence(mount_seq)
+        @action.expects(:mount_folder).with(ssh, name, guestpath).in_sequence(mount_seq)
+        ssh.expects(:exec!).with("sudo chown #{Vagrant.config.ssh.username} #{guestpath}").in_sequence(mount_seq)
+      end
+      Vagrant::SSH.expects(:execute).yields(ssh)
+
+      @action.after_boot
+    end
+  end
+
+  context "mounting the main folder" do
+    setup do
+      @ssh = mock("ssh")
+      @name = "foo"
+      @guestpath = "bar"
+      @sleeptime = 0
+      @limit = 10
+
+      @success_return = false
+    end
+
+    def mount_folder
+      @action.mount_folder(@ssh, @name, @guestpath, @sleeptime)
+    end
+
+    should "execute the proper mount command" do
+      @ssh.expects(:exec!).with("sudo mount -t vboxsf #{@name} #{@guestpath}").returns(@success_return)
+      mount_folder
+    end
+
+    should "test type of text and text string to detect error" do
+      data = mock("data")
+      data.expects(:[]=).with(:result, !@success_return)
+
+      @ssh.expects(:exec!).yields(data, :stderr, "No such device").returns(@success_return)
+      mount_folder
+    end
+
+    should "test type of text and test string to detect success" do
+      data = mock("data")
+      data.expects(:[]=).with(:result, @success_return)
+
+      @ssh.expects(:exec!).yields(data, :stdout, "Nothing such device").returns(@success_return)
+      mount_folder
+    end
+
+    should "raise an ActionException if the command fails constantly" do
+      @ssh.expects(:exec!).times(@limit).returns(!@success_return)
+
+      assert_raises(Vagrant::Actions::ActionException) {
+        mount_folder
+      }
+    end
+
+    should "not raise any exception if the command succeeded" do
+      @ssh.expects(:exec!).once.returns(@success_return)
+
+      assert_nothing_raised {
+        mount_folder
+      }
+    end
+  end
+end

data/test/vagrant/actions/vm/start_test.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class StartActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Start)
+    @mock_vm.stubs(:invoke_callback)
+    mock_config
+  end
+
+  context "execution" do
+    should "invoke the 'boot' around callback" do
+      boot_seq = sequence("boot_seq")
+      @mock_vm.expects(:invoke_around_callback).with(:boot).once.in_sequence(boot_seq).yields
+      @action.expects(:boot).in_sequence(boot_seq)
+      @action.expects(:wait_for_boot).returns(true).in_sequence(boot_seq)
+      @action.execute!
+    end
+
+    should "error and exit if the bootup failed" do
+      fail_boot_seq = sequence("fail_boot_seq")
+      @action.expects(:boot).once.in_sequence(fail_boot_seq)
+      @action.expects(:wait_for_boot).returns(false).in_sequence(fail_boot_seq)
+      @action.expects(:error_and_exit).once.in_sequence(fail_boot_seq)
+      @action.execute!
+    end
+  end
+
+  context "booting" do
+    should "start the VM in headless mode" do
+      @vm.expects(:start).with(:headless, true).once
+      @action.boot
+    end
+  end
+
+  context "waiting for boot" do
+    should "repeatedly ping the SSH port and return false with no response" do
+      seq = sequence('pings')
+      Vagrant::SSH.expects(:up?).times(Vagrant.config[:ssh][:max_tries].to_i - 1).returns(false).in_sequence(seq)
+      Vagrant::SSH.expects(:up?).once.returns(true).in_sequence(seq)
+      assert @action.wait_for_boot(0)
+    end
+
+    should "ping the max number of times then just return" do
+      Vagrant::SSH.expects(:up?).times(Vagrant.config[:ssh][:max_tries].to_i).returns(false)
+      assert !@action.wait_for_boot(0)
+    end
+  end
+
+  context "callbacks" do
+    should "setup the root directory shared folder" do
+      expected = ["vagrant-root", Vagrant::Env.root_path, Vagrant.config.vm.project_directory]
+      assert_equal expected, @action.collect_shared_folders
+    end
+  end
+end

data/test/vagrant/actions/vm/suspend_test.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class SuspendActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Suspend)
+    mock_config
+  end
+
+  context "executing" do
+    setup do
+      @vm.stubs(:running?).returns(true)
+    end
+
+    should "save the state of the VM" do
+      @vm.expects(:save_state).with(true).once
+      @action.execute!
+    end
+
+    should "raise an ActionException if the VM is not running" do
+      @vm.expects(:running?).returns(false)
+      @vm.expects(:save_state).never
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.execute!
+      }
+    end
+  end
+end

data/test/vagrant/actions/vm/up_test.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class UpActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Up)
+    mock_config
+  end
+
+  context "sub-actions" do
+    setup do
+      @default_order = [Vagrant::Actions::VM::Import, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Start]
+    end
+
+    def setup_action_expectations
+      default_seq = sequence("default_seq")
+      @default_order.each do |action|
+        @mock_vm.expects(:add_action).with(action).once.in_sequence(default_seq)
+      end
+    end
+
+    should "do the proper actions by default" do
+      setup_action_expectations
+      @action.prepare
+    end
+
+    should "add in the provisioning step if enabled" do
+      mock_config do |config|
+        config.chef.enabled = true
+      end
+
+      @default_order.push(Vagrant::Actions::VM::Provision)
+      setup_action_expectations
+      @action.prepare
+    end
+
+    should "add in the action to move hard drive if config is set" do
+      mock_config do |config|
+        File.expects(:directory?).with("foo").returns(true)
+        config.vm.hd_location = "foo"
+      end
+
+      @default_order.insert(0, Vagrant::Actions::VM::MoveHardDrive)
+      setup_action_expectations
+      @action.prepare
+    end
+  end
+
+  context "callbacks" do
+    should "call persist and mac address setup after import" do
+      boot_seq = sequence("boot")
+      @action.expects(:persist).once.in_sequence(boot_seq)
+      @action.expects(:setup_mac_address).once.in_sequence(boot_seq)
+      @action.after_import
+    end
+  end
+
+  context "persisting" do
+    should "persist the VM with Env" do
+      @vm.stubs(:uuid)
+      Vagrant::Env.expects(:persist_vm).with(@vm).once
+      @action.persist
+    end
+  end
+
+  context "setting up MAC address" do
+    should "match the mac address with the base" do
+      nic = mock("nic")
+      nic.expects(:macaddress=).once
+
+      @vm.expects(:nics).returns([nic]).once
+      @vm.expects(:save).with(true).once
+
+      @action.setup_mac_address
+    end
+  end
+end