tenderloin 0.2.0

data/test/tenderloin/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(Tenderloin::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 #{Tenderloin.config.ssh.username} #{guestpath}").in_sequence(mount_seq)
+      end
+      Tenderloin::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(Tenderloin::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/tenderloin/actions/vm/start_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class StartActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Tenderloin::Actions::VM::Start)
+    mock_config
+  end
+
+  context "sub-actions" do
+    setup do
+      File.stubs(:file?).returns(true)
+      File.stubs(:exist?).returns(true)
+      @default_order = [Tenderloin::Actions::VM::ForwardPorts, Tenderloin::Actions::VM::SharedFolders, Tenderloin::Actions::VM::Boot]
+    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
+  end
+end

data/test/tenderloin/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(Tenderloin::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(Tenderloin::Actions::ActionException) {
+        @action.execute!
+      }
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class UpActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Tenderloin::Actions::VM::Up)
+    mock_config
+  end
+
+  context "sub-actions" do
+    setup do
+      File.stubs(:file?).returns(true)
+      File.stubs(:exist?).returns(true)
+      @default_order = [Tenderloin::Actions::VM::Import, Tenderloin::Actions::VM::ForwardPorts, Tenderloin::Actions::VM::SharedFolders, Tenderloin::Actions::VM::Boot]
+    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 "raise an ActionException if a dotfile exists but is not a file" do
+      File.expects(:file?).with(Tenderloin::Env.dotfile_path).returns(false)
+      assert_raises(Tenderloin::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+
+    should "not raise an ActionException if dotfile doesn't exist" do
+      setup_action_expectations
+      File.stubs(:exist?).returns(false)
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "not raise an ActionException if dotfile exists but is a file" do
+      File.stubs(:file?).returns(true)
+      File.stubs(:exist?).returns(true)
+      setup_action_expectations
+      assert_nothing_raised { @action.prepare }
+    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(Tenderloin::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, Tenderloin::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)
+      Tenderloin::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

data/test/tenderloin/box_test.rb

@@ -0,0 +1,139 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class BoxTest < Test::Unit::TestCase
+  context "class methods" do
+    context "listing all boxes" do
+      setup do
+        Dir.stubs(:open)
+        File.stubs(:directory?).returns(true)
+
+        @boxes_path = "foo"
+        Tenderloin::Env.stubs(:boxes_path).returns(@boxes_path)
+      end
+
+      should "open the boxes directory" do
+        Dir.expects(:open).with(Tenderloin::Env.boxes_path)
+        Tenderloin::Box.all
+      end
+
+      should "return an array" do
+        result = Tenderloin::Box.all
+        assert result.is_a?(Array)
+      end
+
+      should "not return the '.' and '..' directories" do
+        dir = [".", "..", "..", ".", ".."]
+        Dir.expects(:open).yields(dir)
+        result = Tenderloin::Box.all
+        assert result.empty?
+      end
+
+      should "return the other directories" do
+        dir = [".", "foo", "bar", "baz"]
+        Dir.expects(:open).yields(dir)
+        result = Tenderloin::Box.all
+        assert_equal ["foo", "bar", "baz"], result
+      end
+
+      should "ignore the files" do
+        dir = ["foo", "bar"]
+        files = [true, false]
+        Dir.expects(:open).yields(dir)
+        dir_sequence = sequence("directory")
+        dir.each_with_index do |dir, index|
+          File.expects(:directory?).with(File.join(@boxes_path, dir)).returns(files[index]).in_sequence(dir_sequence)
+        end
+
+        result = Tenderloin::Box.all
+        assert_equal ["foo"], result
+      end
+    end
+
+    context "finding" do
+      setup do
+        @dir = "foo"
+        @name = "bar"
+        Tenderloin::Box.stubs(:directory).with(@name).returns(@dir)
+      end
+
+      should "return nil if the box doesn't exist" do
+        File.expects(:directory?).with(@dir).once.returns(false)
+        assert_nil Tenderloin::Box.find(@name)
+      end
+
+      should "return a box object with the proper name set" do
+        File.expects(:directory?).with(@dir).once.returns(true)
+        result = Tenderloin::Box.find(@name)
+        assert result
+        assert_equal @name, result.name
+      end
+    end
+
+    context "adding" do
+      setup do
+        @name = "foo"
+        @uri = "bar"
+      end
+
+      should "create a new instance, set the variables, and add it" do
+        box = mock("box")
+        box.expects(:name=).with(@name)
+        box.expects(:uri=).with(@uri)
+        box.expects(:add).once
+        Tenderloin::Box.expects(:new).returns(box)
+        Tenderloin::Box.add(@name, @uri)
+      end
+    end
+
+    context "box directory" do
+      setup do
+        @name = "foo"
+        @box_dir = File.join(Tenderloin::Env.boxes_path, @name)
+      end
+
+      should "return the boxes_path joined with the name" do
+        assert_equal @box_dir, Tenderloin::Box.directory(@name)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @box = Tenderloin::Box.new
+    end
+
+    should "execute the Add action when add is called" do
+      @box.expects(:execute!).with(Tenderloin::Actions::Box::Add).once
+      @box.add
+    end
+
+    context "box directory" do
+      setup do
+        @box.name = "foo"
+      end
+
+      should "return the boxes_path joined with the name" do
+        result = mock("object")
+        Tenderloin::Box.expects(:directory).with(@box.name).returns(result)
+        assert result.equal?(@box.directory)
+      end
+    end
+
+    context "destroying" do
+      should "execute the destroy action" do
+        @box.expects(:execute!).with(Tenderloin::Actions::Box::Destroy).once
+        @box.destroy
+      end
+    end
+
+    context "ovf file" do
+      setup do
+        @box.stubs(:directory).returns("foo")
+      end
+
+      should "be the directory joined with the config ovf file" do
+        assert_equal File.join(@box.directory, Tenderloin.config.vm.box_ovf), @box.ovf_file
+      end
+    end
+  end
+end

data/test/tenderloin/busy_test.rb

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class BusyTest < Test::Unit::TestCase
+  context "waiting for not busy" do
+    setup do
+      Tenderloin::Busy.reset_trap_thread!
+    end
+
+    should "run in a thread" do
+      Thread.expects(:new).once.returns(nil)
+      Tenderloin::Busy.wait_for_not_busy
+    end
+
+    should "not start a thread multiple times" do
+      Thread.expects(:new).once.returns("foo")
+      Tenderloin::Busy.wait_for_not_busy
+    end
+  end
+
+  context "during an action in a busy block" do
+    should "report as busy" do
+      Tenderloin.busy do
+        # Inside the block Tenderloin.busy? should be true
+        assert Tenderloin.busy?
+      end
+
+      #After the block finishes Tenderloin.busy? should be false
+      assert !Tenderloin.busy?
+    end
+
+    should "set busy to false upon exception and reraise the error" do
+      assert_raise Exception do
+        Tenderloin.busy do
+          assert Tenderloin.busy?
+          raise Exception
+        end
+      end
+
+      assert !Tenderloin.busy?
+    end
+
+    should "complete the trap thread even if an exception occurs" do
+      trap_thread = mock("trap_thread")
+      trap_thread.expects(:join).once
+      Tenderloin::Busy.stubs(:trap_thread).returns(trap_thread)
+
+      assert_raise Exception do
+        Tenderloin.busy do
+          raise Exception
+        end
+      end
+    end
+
+    should "report busy to the outside world regardless of thread" do
+      Thread.new do
+        Tenderloin.busy do
+          sleep(2)
+        end
+      end
+      # Give the thread time to start
+      sleep(1)
+
+      # While the above thread is executing tenderloin should be busy
+      assert Tenderloin.busy?
+    end
+
+    should "run the action in a new thread" do
+      runner_thread = nil
+      Tenderloin.busy do
+        runner_thread = Thread.current
+      end
+
+      assert_not_equal Thread.current, runner_thread
+    end
+
+    should "trap INT" do
+      trap_seq = sequence("trap_seq")
+      Signal.expects(:trap).with("INT", anything).once.in_sequence(trap_seq)
+      Signal.expects(:trap).with("INT", "DEFAULT").once.in_sequence(trap_seq)
+      Tenderloin.busy do; end
+    end
+  end
+end