bmabey-vagrant 0.2.0

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

@@ -0,0 +1,181 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class PackageActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Package, "bing", [])
+
+    mock_config
+  end
+
+  context "initialization" do
+    def get_action(*args)
+      runner, vm, action = mock_action(Vagrant::Actions::VM::Package, *args)
+      return action
+    end
+
+    should "make out_path 'package' by default if nil is given" do
+      action = get_action(nil, [])
+      assert_equal "package", action.out_path
+    end
+
+    should "make include files an empty array by default" do
+      action = get_action("foo", nil)
+      assert action.include_files.is_a?(Array)
+      assert action.include_files.empty?
+    end
+  end
+
+  context "executing" do
+    setup do
+      @action.stubs(:compress)
+    end
+
+    should "compress" do
+      package_seq = sequence("package_seq")
+      @action.expects(:compress).in_sequence(package_seq)
+      @action.execute!
+    end
+  end
+
+  context "tar path" do
+    should "be the temporary directory with the name and extension attached" do
+      pwd = "foo"
+      FileUtils.stubs(:pwd).returns(pwd)
+      assert_equal File.join(pwd, "#{@action.out_path}#{@runner.env.config.package.extension}"), @action.tar_path
+    end
+  end
+
+  context "temp path" do
+    setup do
+      @export = mock("export")
+      @action.expects(:export_action).returns(@export)
+    end
+
+    should "use the export action's temp dir" do
+      path = mock("path")
+      @export.expects(:temp_dir).returns(path)
+      @action.temp_path
+    end
+  end
+
+  context "compression" do
+    setup do
+      @tar_path = "foo"
+      @action.stubs(:tar_path).returns(@tar_path)
+
+      @temp_path = "foo"
+      @action.stubs(:temp_path).returns(@temp_path)
+
+      @include_files = []
+      @action.stubs(:include_files).returns(@include_files)
+
+      @pwd = "bar"
+      FileUtils.stubs(:pwd).returns(@pwd)
+      FileUtils.stubs(:cd)
+
+      @file = mock("file")
+      File.stubs(:open).yields(@file)
+
+      @output = mock("output")
+      @tar = Archive::Tar::Minitar
+      Archive::Tar::Minitar::Output.stubs(:open).yields(@output)
+      @tar.stubs(:pack_file)
+    end
+
+    should "open the tar file with the tar path properly" do
+      File.expects(:open).with(@tar_path, File::CREAT | File::WRONLY, 0644).once
+      @action.compress
+    end
+
+    should "open tar file" do
+      Archive::Tar::Minitar::Output.expects(:open).with(@file).once
+      @action.compress
+    end
+
+    #----------------------------------------------------------------
+    # Methods below this comment test the block yielded by Minitar open
+    #----------------------------------------------------------------
+    should "cd to the directory and append the directory" do
+      @files = []
+      compress_seq = sequence("compress_seq")
+
+      FileUtils.expects(:pwd).once.returns(@pwd).in_sequence(compress_seq)
+      FileUtils.expects(:cd).with(@temp_path).in_sequence(compress_seq)
+      Dir.expects(:glob).returns(@files).in_sequence(compress_seq)
+
+      5.times do |i|
+        file = mock("file#{i}")
+        @tar.expects(:pack_file).with(file, @output).once.in_sequence(compress_seq)
+        @files << file
+      end
+
+      FileUtils.expects(:cd).with(@pwd).in_sequence(compress_seq)
+      @action.compress
+    end
+
+    should "pop back to the current directory even if an exception is raised" do
+      cd_seq = sequence("cd_seq")
+      FileUtils.expects(:cd).with(@temp_path).raises(Exception).in_sequence(cd_seq)
+      FileUtils.expects(:cd).with(@pwd).in_sequence(cd_seq)
+
+      assert_raises(Exception) {
+        @action.compress
+      }
+    end
+
+    should "add included files when passed" do
+      compress_seq = sequence("compress")
+      @files = []
+      5.times do |i|
+        file = mock("file#{i}")
+        @tar.expects(:pack_file).with(file, @output).once.in_sequence(compress_seq)
+        @files << file
+      end
+
+      @action.expects(:include_files).returns(@files)
+      @action.compress
+    end
+
+    should "not add files when none are specified" do
+      @tar.expects(:pack_file).never
+      Dir.expects(:glob).once.returns([])
+      @action.compress
+    end
+  end
+
+  context "preparing the action" do
+    context "checking include files" do
+      setup do
+        @include_files = ['fooiest', 'booiest']
+        @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Package, "bing", @include_files)
+        @runner.stubs(:find_action).returns("foo")
+      end
+
+      should "check that all the include files exist" do
+        @include_files.each do |file|
+          File.expects(:exists?).with(file).returns(true)
+        end
+        @action.prepare
+      end
+
+      should "raise an exception when an include file does not exist" do
+        File.expects(:exists?).once.returns(false)
+        assert_raises(Vagrant::Actions::ActionException) { @action.prepare }
+      end
+    end
+
+    context "loading export reference" do
+      should "find and store a reference to the export action" do
+        @export = mock("export")
+        @runner.expects(:find_action).with(Vagrant::Actions::VM::Export).once.returns(@export)
+        @action.prepare
+        assert @export.equal?(@action.export_action)
+      end
+
+      should "raise an exception if the export action couldn't be found" do
+        @runner.expects(:find_action).with(Vagrant::Actions::VM::Export).once.returns(nil)
+        assert_raises(Vagrant::Actions::ActionException) { @action.prepare }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ProvisionActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Provision)
+    mock_config
+  end
+
+  context "initialization" do
+    should "have a nil provisioner by default" do
+      assert_nil @action.provisioner
+    end
+  end
+
+  context "executing" do
+    should "do nothing if the provisioner is nil" do
+      @action.expects(:provisioner).returns(nil)
+      assert_nothing_raised { @action.execute! }
+    end
+
+    should "call `provision!` on the provisioner" do
+      provisioner = mock("provisioner")
+      provisioner.expects(:provision!).once
+      @action.expects(:provisioner).twice.returns(provisioner)
+      @action.execute!
+    end
+  end
+
+  context "preparing" do
+    context "with a nil provisioner" do
+      setup do
+        mock_config do |config|
+          config.vm.provisioner = nil
+        end
+      end
+
+      should "not set a provisioner if set to nil" do
+        @action.prepare
+        assert_nil @action.provisioner
+      end
+    end
+
+    context "with a Class provisioner" do
+      setup do
+        @instance = mock("instance")
+        @instance.stubs(:is_a?).with(Vagrant::Provisioners::Base).returns(true)
+        @instance.stubs(:prepare)
+        @klass = mock("klass")
+        @klass.stubs(:is_a?).with(Class).returns(true)
+        @klass.stubs(:new).with(@runner.env).returns(@instance)
+
+        mock_config do |config|
+          config.vm.provisioner = @klass
+        end
+      end
+
+      should "set the provisioner to an instantiation of the class" do
+        @klass.expects(:new).with(@runner.env).once.returns(@instance)
+        assert_nothing_raised { @action.prepare }
+        assert_equal @instance, @action.provisioner
+      end
+
+      should "call prepare on the instance" do
+        @instance.expects(:prepare).once
+        @action.prepare
+      end
+
+      should "raise an exception if the class is not a subclass of the provisioner base" do
+        @instance.expects(:is_a?).with(Vagrant::Provisioners::Base).returns(false)
+        assert_raises(Vagrant::Actions::ActionException) {
+          @action.prepare
+        }
+      end
+    end
+
+    context "with a Symbol provisioner" do
+      def provisioner_expectation(symbol, provisioner)
+        mock_config do |config|
+          config.vm.provisioner = symbol
+        end
+
+        instance = mock("instance")
+        instance.expects(:prepare).once
+        provisioner.expects(:new).with(@runner.env).returns(instance)
+        assert_nothing_raised { @action.prepare }
+        assert_equal instance, @action.provisioner
+      end
+
+      should "raise an ActionException if its an unknown symbol" do
+        mock_config do |config|
+          config.vm.provisioner = :this_will_never_exist
+        end
+
+        assert_raises(Vagrant::Actions::ActionException) {
+          @action.prepare
+        }
+      end
+
+      should "set :chef_solo to the ChefSolo provisioner" do
+        provisioner_expectation(:chef_solo, Vagrant::Provisioners::ChefSolo)
+      end
+
+      should "set :chef_server to the ChefServer provisioner" do
+        provisioner_expectation(:chef_server, Vagrant::Provisioners::ChefServer)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+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::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Boot]
+      @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
+      env = mock_environment do |config|
+        # Dummy provisioner to test
+        config.vm.provisioner = "foo"
+      end
+
+      @runner.stubs(:env).returns(env)
+
+      @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,176 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class SharedFoldersActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @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 "before boot" do
+    should "clear folders and create metadata, in order" do
+      before_seq = sequence("before")
+      @action.expects(:clear_shared_folders).once.in_sequence(before_seq)
+      @action.expects(:create_metadata).once.in_sequence(before_seq)
+      @action.before_boot
+    end
+  end
+
+  context "collecting shared folders" do
+    setup do
+      File.stubs(:expand_path).returns("baz")
+    end
+
+    should "convert the vagrant config values into an array" do
+      env = mock_environment do |config|
+        config.vm.shared_folders.clear
+        config.vm.share_folder("foo", "bar", "baz")
+      end
+
+      @runner.expects(:env).returns(env)
+
+      result = [["foo", "baz", "bar"]]
+      assert_equal result, @action.shared_folders
+    end
+
+    should "expand the path of the host folder" do
+      File.expects(:expand_path).with("baz").once.returns("expanded_baz")
+
+      env = mock_environment do |config|
+        config.vm.shared_folders.clear
+        config.vm.share_folder("foo", "bar", "baz")
+      end
+
+      @runner.expects(:env).returns(env)
+
+      result = [["foo", "expanded_baz", "bar"]]
+      assert_equal result, @action.shared_folders
+    end
+  end
+
+  context "clearing shared folders" do
+    setup do
+      @shared_folder = mock("shared_folder")
+      @shared_folders = [@shared_folder]
+      @vm.stubs(:shared_folders).returns(@shared_folders)
+    end
+
+    should "call destroy on each shared folder then reload" do
+      destroy_seq = sequence("destroy")
+      @shared_folders.each do |sf|
+        sf.expects(:destroy).once.in_sequence(destroy_seq)
+      end
+
+      @runner.expects(:reload!).once.in_sequence(destroy_seq)
+      @action.clear_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.create_metadata
+    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 #{@runner.env.config.ssh.username} #{guestpath}").in_sequence(mount_seq)
+      end
+      @runner.env.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 -o uid=#{@runner.env.config.ssh.username},gid=#{@runner.env.config.ssh.username} #{@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
+
+    should "add uid AND gid to mount" do
+      uid = "foo"
+      gid = "bar"
+      env = mock_environment do |config|
+        config.vm.shared_folder_uid = uid
+        config.vm.shared_folder_gid = gid
+      end
+
+      @runner.expects(:env).twice.returns(env)
+
+      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=#{uid},gid=#{gid} #{@name} #{@guestpath}").returns(@success_return)
+      mount_folder
+    end
+  end
+end