tenderloin 0.2.0

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

@@ -0,0 +1,88 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ExportActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Tenderloin::Actions::VM::Export)
+    mock_config
+  end
+
+  context "executing" do
+    should "setup the temp dir then export" do
+      exec_seq = sequence('execute')
+      @action.expects(:setup_temp_dir).once.in_sequence(exec_seq)
+      @action.expects(:export).once.in_sequence(exec_seq)
+      @action.execute!
+    end
+  end
+
+  context "setting up the temporary directory" do
+    setup do
+      @time_now = Time.now.to_i.to_s
+      Time.stubs(:now).returns(@time_now)
+
+      @tmp_path = "foo"
+      Tenderloin::Env.stubs(:tmp_path).returns(@tmp_path)
+
+      @temp_dir = File.join(Tenderloin::Env.tmp_path, @time_now)
+      FileUtils.stubs(:mkpath)
+    end
+
+    should "create the temporary directory using the current time" do
+      FileUtils.expects(:mkpath).with(@temp_dir).once
+      @action.setup_temp_dir
+    end
+
+    should "set the temporary directory to the temp_dir variable" do
+      @action.setup_temp_dir
+      assert_equal @temp_dir, @action.temp_dir
+    end
+  end
+
+  context "path to OVF file" do
+    setup do
+      @temp_dir = "foo"
+      @action.stubs(:temp_dir).returns(@temp_dir)
+    end
+
+    should "be the temporary directory joined with the OVF filename" do
+      assert_equal File.join(@temp_dir, Tenderloin.config.vm.box_ovf), @action.ovf_path
+    end
+  end
+
+  context "exporting" do
+    setup do
+      @ovf_path = mock("ovf_path")
+      @action.stubs(:ovf_path).returns(@ovf_path)
+    end
+
+    should "call export on the runner with the ovf path" do
+      @vm.expects(:export).with(@ovf_path, {}, true).once
+      @action.export
+    end
+  end
+
+  context "cleanup" do
+    setup do
+      @temp_dir = "foo"
+      @action.stubs(:temp_dir).returns(@temp_dir)
+    end
+
+    should "remove the temporary directory" do
+      FileUtils.expects(:rm_r).with(@temp_dir).once
+      @action.cleanup
+    end
+
+    should "not remove a directory if temp_dir is nil" do
+      FileUtils.expects(:rm_r).never
+      @action.stubs(:temp_dir).returns(nil)
+      @action.cleanup
+    end
+  end
+
+  context "rescue" do
+    should "call cleanup method" do
+      @action.expects(:cleanup).once
+      @action.rescue(nil)
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ForwardPortsActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Tenderloin::Actions::VM::ForwardPorts)
+    mock_config
+  end
+
+  context "execution" do
+    should "clear all previous ports and forward new ports" do
+      exec_seq = sequence("exec_seq")
+      @action.expects(:clear).once.in_sequence(exec_seq)
+      @action.expects(:forward_ports).once.in_sequence(exec_seq)
+      @action.execute!
+    end
+  end
+
+  context "forwarding ports" do
+    should "create a port forwarding for the VM" do
+      forwarded_ports = mock("forwarded_ports")
+
+      Tenderloin.config.vm.forwarded_ports.each do |name, opts|
+        forwarded_ports.expects(:<<).with do |port|
+          assert_equal name, port.name
+          assert_equal opts[:hostport], port.hostport
+          assert_equal opts[:guestport], port.guestport
+          true
+        end
+      end
+
+      @vm.expects(:forwarded_ports).returns(forwarded_ports)
+      @vm.expects(:save).with(true).once
+      @action.forward_ports
+    end
+  end
+
+  context "clearing forwarded ports" do
+    should "call destroy on all forwarded ports" do
+      forwarded_ports = []
+      5.times do |i|
+        port = mock("port#{i}")
+        port.expects(:destroy).with(true).once
+        forwarded_ports << port
+      end
+
+      @vm.expects(:forwarded_ports).returns(forwarded_ports)
+      @action.clear
+    end
+  end
+end

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

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

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

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ImportActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @import = mock_action(Tenderloin::Actions::VM::Import)
+
+    @ovf_file = "foo"
+    @box = mock("box")
+    @box.stubs(:ovf_file).returns(@ovf_file)
+    Tenderloin::Env.stubs(:box).returns(@box)
+
+    VirtualBox::VM.stubs(:import)
+  end
+
+  should "run in a busy block" do
+    Tenderloin::Busy.expects(:busy).once
+    @import.execute!
+  end
+
+  should "invoke an around callback around the import" do
+    @mock_vm.expects(:invoke_around_callback).with(:import).once
+    @import.execute!
+  end
+
+  should "call import on VirtualBox::VM with the proper base" do
+    VirtualBox::VM.expects(:import).once.with(@ovf_file)
+    @import.execute!
+  end
+
+  should "set the resulting VM as the VM of the Tenderloin VM object" do
+    new_vm = mock("new_vm")
+    @mock_vm.expects(:vm=).with(new_vm).once
+    VirtualBox::VM.expects(:import).returns(new_vm)
+    @import.execute!
+  end
+end

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

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class MoveHardDriveActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Tenderloin::Actions::VM::MoveHardDrive)
+    @hd_location = "/foo"
+    mock_config do |config|
+      File.expects(:directory?).with(@hd_location).returns(true)
+      config.vm.hd_location = @hd_location
+    end
+  end
+
+
+  should "be able to identifiy a hard drive within the storage controllers" do
+    hd = mock('hd')
+    hd_image = mock('hd_image')
+    hd_image.expects(:is_a?).returns(true)
+    hd.expects(:image).returns(hd_image)
+
+    dvd = mock('dvd')
+    controller = mock('controller')
+    controller.expects(:devices).returns([hd, dvd])
+
+    @vm.expects(:storage_controllers).once.returns([controller])
+    assert_equal @action.find_hard_drive, hd
+  end
+
+  context "execution" do
+    should "error and exit if the vm is not powered off" do
+      @mock_vm.expects(:powered_off?).returns(false)
+      @action.expects(:error_and_exit).once
+      @action.execute!
+    end
+
+    should "move the hard drive if vm is powered off" do
+      @mock_vm.expects(:powered_off?).returns(true)
+      @action.expects(:error_and_exit).never
+      @action.expects(:destroy_drive_after).once
+      @action.execute!
+    end
+  end
+
+  context "new image path" do
+    setup do
+      @hd = mock("hd")
+      @image = mock("image")
+      @filename = "foo"
+      @hd.stubs(:image).returns(@image)
+      @image.stubs(:filename).returns(@filename)
+      @action.stubs(:hard_drive).returns(@hd)
+    end
+
+    should "be the configured hd location and the existing hard drive filename" do
+      joined = File.join(Tenderloin.config.vm.hd_location, @filename)
+      assert_equal joined, @action.new_image_path
+    end
+  end
+
+  context "cloning and attaching new image" do
+    setup do
+      @hd = mock("hd")
+      @image = mock("image")
+      @hd.stubs(:image).returns(@image)
+      @action.stubs(:hard_drive).returns(@hd)
+      @new_image_path = "foo"
+      @action.stubs(:new_image_path).returns(@new_image_path)
+    end
+
+    should "clone to the new path" do
+      new_image = mock("new_image")
+      @image.expects(:clone).with(@new_image_path, Tenderloin.config.vm.disk_image_format, true).returns(new_image).once
+      @hd.expects(:image=).with(new_image).once
+      @vm.expects(:save).once
+      @action.clone_and_attach
+    end
+  end
+
+  context "destroying the old image" do
+    setup do
+      @hd = mock("hd")
+      @action.stubs(:hard_drive).returns(@hd)
+    end
+
+    should "yield the block, and destroy the old image after" do
+      image = mock("image")
+      image.stubs(:filename).returns("foo")
+      destroy_seq = sequence("destroy_seq")
+      @hd.expects(:image).returns(image).in_sequence(destroy_seq)
+      @hd.expects(:foo).once.in_sequence(destroy_seq)
+      image.expects(:destroy).with(true).once.in_sequence(destroy_seq)
+
+      @action.destroy_drive_after { @hd.foo }
+    end
+
+    # Ensures that the image is not destroyed in an "ensure" block
+    should "not destroy the image if an exception is raised" do
+      image = mock("image")
+      image.expects(:destroy).never
+      @hd.expects(:image).returns(image)
+
+      assert_raises(Exception) do
+        @action.destroy_drive_after do
+          raise Exception.new("FOO")
+        end
+      end
+    end
+  end
+end

data/test/tenderloin/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(Tenderloin::Actions::VM::Package, "bing", [])
+
+    mock_config
+  end
+
+  context "initialization" do
+    def get_action(*args)
+      runner, vm, action = mock_action(Tenderloin::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}#{Tenderloin.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(Tenderloin::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(Tenderloin::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(Tenderloin::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(Tenderloin::Actions::VM::Export).once.returns(nil)
+        assert_raises(Tenderloin::Actions::ActionException) { @action.prepare }
+      end
+    end
+  end
+end

data/test/tenderloin/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(Tenderloin::Actions::VM::Provision)
+
+    Tenderloin::SSH.stubs(:execute)
+    Tenderloin::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(Tenderloin.config.chef.cookbooks_path, Tenderloin::Env.root_path).returns("foo")
+      @action.expects(:cookbooks_path).returns("bar")
+      assert_equal ["tenderloin-provisioning", "foo", "bar"], @action.collect_shared_folders
+    end
+  end
+
+  context "cookbooks path" do
+    should "return the proper cookbook path" do
+      cookbooks_path = File.join(Tenderloin.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 #{Tenderloin.config.ssh.username} #{Tenderloin.config.chef.provisioning_path}")
+      Tenderloin::SSH.expects(:execute).yields(ssh)
+      @action.chown_provisioning_folder
+    end
+  end
+
+  context "generating and uploading json" do
+    def assert_json
+      Tenderloin::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
+      Tenderloin.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 Tenderloin.config.vm.project_directory, data["tenderloin"]["directory"]
+      end
+    end
+
+    should "add the config to the JSON" do
+      assert_json do |data|
+        assert_equal Tenderloin.config.vm.project_directory, data["tenderloin"]["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(Tenderloin.config.chef.provisioning_path, "dna.json").once.returns("baz")
+      Tenderloin::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 "#{Tenderloin.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(Tenderloin.config.chef.provisioning_path, "solo.rb").once.returns("bar")
+      Tenderloin::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 #{Tenderloin.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json").once
+      Tenderloin::SSH.expects(:execute).yields(ssh)
+      @action.run_chef_solo
+    end
+  end
+end

data/test/tenderloin/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(Tenderloin::Actions::VM::Reload)
+    mock_config
+  end
+
+  context "sub-actions" do
+    setup do
+      @default_order = [Tenderloin::Actions::VM::ForwardPorts, Tenderloin::Actions::VM::SharedFolders, Tenderloin::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(Tenderloin::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(Tenderloin::Actions::VM::Provision)
+      setup_action_expectations
+      @action.prepare
+    end
+  end
+end

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