tenderloin 0.2.0

data/test/tenderloin/env_test.rb

@@ -0,0 +1,345 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class EnvTest < Test::Unit::TestCase
+  def mock_persisted_vm(returnvalue="foovm")
+    filemock = mock("filemock")
+    filemock.expects(:read).returns("foo")
+    Tenderloin::VM.expects(:find).with("foo").returns(returnvalue)
+    File.expects(:open).with(Tenderloin::Env.dotfile_path).once.yields(filemock)
+    File.expects(:file?).with(Tenderloin::Env.dotfile_path).once.returns(true)
+    Tenderloin::Env.load_vm!
+  end
+
+  setup do
+    mock_config
+    Tenderloin::Box.stubs(:find).returns("foo")
+  end
+
+  context "requiring a VM" do
+    setup do
+      Tenderloin::Env.stubs(:require_root_path)
+      Tenderloin::Env.stubs(:error_and_exit)
+    end
+
+    should "require root path" do
+      Tenderloin::Env.expects(:require_root_path).once
+      Tenderloin::Env.require_persisted_vm
+    end
+
+    should "error and exit if no persisted VM was found" do
+      assert_nil Tenderloin::Env.persisted_vm
+      Tenderloin::Env.expects(:error_and_exit).once
+      Tenderloin::Env.require_persisted_vm
+    end
+
+    should "return and continue if persisted VM is found" do
+      mock_persisted_vm
+      Tenderloin::Env.expects(:error_and_exit).never
+      Tenderloin::Env.require_persisted_vm
+    end
+  end
+
+  context "loading home directory" do
+    setup do
+      @home_dir = File.expand_path(Tenderloin.config.tenderloin.home)
+
+      File.stubs(:directory?).returns(true)
+      FileUtils.stubs(:mkdir_p)
+    end
+
+    should "create each directory if it doesn't exist" do
+      create_seq = sequence("create_seq")
+      File.stubs(:directory?).returns(false)
+      Tenderloin::Env::HOME_SUBDIRS.each do |subdir|
+        FileUtils.expects(:mkdir_p).with(File.join(@home_dir, subdir)).in_sequence(create_seq)
+      end
+
+      Tenderloin::Env.load_home_directory!
+    end
+
+    should "not create directories if they exist" do
+      File.stubs(:directory?).returns(true)
+      FileUtils.expects(:mkdir_p).never
+      Tenderloin::Env.load_home_directory!
+    end
+  end
+
+  context "loading config" do
+    setup do
+      @root_path = "/foo"
+      Tenderloin::Env.stubs(:root_path).returns(@root_path)
+      Tenderloin::Env.stubs(:box).returns(nil)
+      File.stubs(:exist?).returns(false)
+      Tenderloin::Config.stubs(:execute!)
+      Tenderloin::Config.stubs(:reset!)
+    end
+
+    should "reset the configuration object" do
+      Tenderloin::Config.expects(:reset!).once
+      Tenderloin::Env.load_config!
+    end
+
+    should "load from the project root" do
+      File.expects(:exist?).with(File.join(PROJECT_ROOT, "config", "default.rb")).once
+      Tenderloin::Env.load_config!
+    end
+
+    should "load from the root path" do
+      File.expects(:exist?).with(File.join(@root_path, Tenderloin::Env::ROOTFILE_NAME)).once
+      Tenderloin::Env.load_config!
+    end
+
+    should "not load from the root path if nil" do
+      Tenderloin::Env.stubs(:root_path).returns(nil)
+      File.expects(:exist?).with(File.join(@root_path, Tenderloin::Env::ROOTFILE_NAME)).never
+      Tenderloin::Env.load_config!
+    end
+
+    should "not load from the box directory if it is nil" do
+      Tenderloin::Env.expects(:box).once.returns(nil)
+      Tenderloin::Env.load_config!
+    end
+
+    should "load from the box directory if it is not nil" do
+      dir = "foo"
+      box = mock("box")
+      box.stubs(:directory).returns(dir)
+      Tenderloin::Env.expects(:box).twice.returns(box)
+      File.expects(:exist?).with(File.join(dir, Tenderloin::Env::ROOTFILE_NAME)).once
+      Tenderloin::Env.load_config!
+    end
+
+    should "load the files only if exist? returns true" do
+      File.expects(:exist?).once.returns(true)
+      Tenderloin::Env.expects(:load).once
+      Tenderloin::Env.load_config!
+    end
+
+    should "not load the files if exist? returns false" do
+      Tenderloin::Env.expects(:load).never
+      Tenderloin::Env.load_config!
+    end
+
+    should "execute after loading" do
+      File.expects(:exist?).once.returns(true)
+      Tenderloin::Env.expects(:load).once
+      Tenderloin::Config.expects(:execute!).once
+      Tenderloin::Env.load_config!
+    end
+  end
+
+  context "initial load" do
+    test "load! should load the config and set the persisted_uid" do
+      Tenderloin::Env.expects(:load_config!).once
+      Tenderloin::Env.expects(:load_vm!).once
+      Tenderloin::Env.expects(:load_root_path!).once
+      Tenderloin::Env.expects(:load_home_directory!).once
+      Tenderloin::Env.expects(:load_box!).once
+      Tenderloin::Env.load!
+    end
+  end
+
+  context "persisting the VM into a file" do
+    setup do
+      mock_config
+    end
+
+    test "should save it to the dotfile path" do
+      vm = mock("vm")
+      vm.stubs(:uuid).returns("foo")
+
+      filemock = mock("filemock")
+      filemock.expects(:write).with(vm.uuid)
+      File.expects(:open).with(Tenderloin::Env.dotfile_path, 'w+').once.yields(filemock)
+      Tenderloin::Env.persist_vm(vm)
+    end
+  end
+
+  context "loading the UUID out from the persisted file" do
+    setup do
+      File.stubs(:file?).returns(true)
+    end
+
+    should "loading of the uuid from the dotfile" do
+      mock_persisted_vm
+      assert_equal 'foovm', Tenderloin::Env.persisted_vm
+    end
+
+    should "do nothing if the root path is nil" do
+      File.expects(:open).never
+      Tenderloin::Env.stubs(:root_path).returns(nil)
+      Tenderloin::Env.load_vm!
+    end
+
+    should "do nothing if dotfile is not a file" do
+      File.expects(:file?).returns(false)
+      File.expects(:open).never
+      Tenderloin::Env.load_vm!
+    end
+
+    should "uuid should be nil if dotfile didn't exist" do
+      File.expects(:open).raises(Errno::ENOENT)
+      Tenderloin::Env.load_vm!
+      assert_nil Tenderloin::Env.persisted_vm
+    end
+
+    should "should build up the dotfile out of the root path and the dotfile name" do
+      assert_equal File.join(Tenderloin::Env.root_path, Tenderloin.config.tenderloin.dotfile_name), Tenderloin::Env.dotfile_path
+    end
+  end
+
+  context "loading the root path" do
+    should "default the path to the pwd if nil" do
+      @path = mock("path")
+      @path.stubs(:to_s).returns("/")
+      Pathname.expects(:new).with(Dir.pwd).returns(@path)
+      Tenderloin::Env.load_root_path!(nil)
+    end
+
+    should "not default the path to pwd if its not nil" do
+      @path = mock("path")
+      @path.stubs(:to_s).returns("/")
+      Pathname.expects(:new).never
+      Tenderloin::Env.load_root_path!(@path)
+    end
+
+    should "should walk the parent directories looking for rootfile" do
+      paths = [
+        Pathname.new("/foo/bar/baz"),
+        Pathname.new("/foo/bar"),
+        Pathname.new("/foo")
+      ]
+
+      search_seq = sequence("search_seq")
+      paths.each do |path|
+        File.expects(:exist?).with("#{path}/#{Tenderloin::Env::ROOTFILE_NAME}").returns(false).in_sequence(search_seq)
+      end
+
+      assert !Tenderloin::Env.load_root_path!(paths.first)
+    end
+
+    should "return false if not found" do
+      path = Pathname.new("/")
+      assert !Tenderloin::Env.load_root_path!(path)
+    end
+
+    should "return false if not found on windows-style root" do
+      path = Pathname.new("C:.")
+      assert !Tenderloin::Env.load_root_path!(path)
+    end
+
+    should "should set the path for the rootfile" do
+      path = "/foo"
+      File.expects(:exist?).with("#{path}/#{Tenderloin::Env::ROOTFILE_NAME}").returns(true)
+
+      assert Tenderloin::Env.load_root_path!(Pathname.new(path))
+      assert_equal path, Tenderloin::Env.root_path
+    end
+  end
+
+  context "home directory paths" do
+    should "return the expanded config for `home_path`" do
+      assert_equal File.expand_path(Tenderloin.config.tenderloin.home), Tenderloin::Env.home_path
+    end
+
+    should "return the home_path joined with tmp for a tmp path" do
+      @home_path = "foo"
+      Tenderloin::Env.stubs(:home_path).returns(@home_path)
+      assert_equal File.join(@home_path, "tmp"), Tenderloin::Env.tmp_path
+    end
+
+    should "return the boxes path" do
+      @home_path = "foo"
+      Tenderloin::Env.stubs(:home_path).returns(@home_path)
+      assert_equal File.join(@home_path, "boxes"), Tenderloin::Env.boxes_path
+    end
+  end
+
+  context "loading box" do
+    setup do
+      @box = mock("box")
+
+      Tenderloin::Env.stubs(:load_config!)
+      Tenderloin::Env.stubs(:root_path).returns("foo")
+    end
+
+    should "do nothing if the root path is nil" do
+      Tenderloin::Box.expects(:find).never
+      Tenderloin::Env.stubs(:root_path).returns(nil)
+      Tenderloin::Env.load_vm!
+    end
+
+    should "not load the box if its not set" do
+      mock_config do |config|
+        config.vm.box = nil
+      end
+
+      Tenderloin::Box.expects(:find).never
+      Tenderloin::Env.load_box!
+    end
+
+    should "set the box to what is found by the Box class" do
+      Tenderloin::Box.expects(:find).with(Tenderloin.config.vm.box).once.returns(@box)
+      Tenderloin::Env.load_box!
+      assert @box.equal?(Tenderloin::Env.box)
+    end
+
+    should "load the config if a box is loaded" do
+      Tenderloin::Env.expects(:load_config!).once
+      Tenderloin::Box.expects(:find).returns(@box)
+      Tenderloin::Env.load_box!
+    end
+  end
+
+  context "requiring boxes" do
+    setup do
+      Tenderloin::Env.stubs(:require_root_path)
+      Tenderloin::Env.stubs(:error_and_exit)
+    end
+
+    should "require root path" do
+      Tenderloin::Env.expects(:require_root_path).once
+      Tenderloin::Env.require_box
+    end
+
+    should "error and exit if no box is found" do
+      mock_config do |config|
+        config.vm.box = nil
+      end
+
+      Tenderloin::Env.expects(:box).returns(nil)
+      Tenderloin::Env.expects(:error_and_exit).once.with() do |msg|
+        assert msg =~ /no base box was specified/i
+        true
+      end
+      Tenderloin::Env.require_box
+    end
+
+    should "error and exit if box is specified but doesn't exist" do
+      mock_config do |config|
+        config.vm.box = "foo"
+      end
+
+      Tenderloin::Env.expects(:box).returns(nil)
+      Tenderloin::Env.expects(:error_and_exit).once.with() do |msg|
+        assert msg =~ /does not exist/i
+        true
+      end
+      Tenderloin::Env.require_box
+    end
+  end
+
+  context "requiring root_path" do
+    should "error and exit if no root_path is set" do
+      Tenderloin::Env.expects(:root_path).returns(nil)
+      Tenderloin::Env.expects(:error_and_exit).once
+      Tenderloin::Env.require_root_path
+    end
+
+    should "not error and exit if root_path is set" do
+      Tenderloin::Env.expects(:root_path).returns("foo")
+      Tenderloin::Env.expects(:error_and_exit).never
+      Tenderloin::Env.require_root_path
+    end
+  end
+end

data/test/tenderloin/ssh_test.rb

@@ -0,0 +1,103 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class SshTest < Test::Unit::TestCase
+  setup do
+    mock_config
+  end
+
+  context "connecting to SSH" do
+    setup do
+      @script = Tenderloin::SSH::SCRIPT
+    end
+
+    test "should call exec with defaults when no options are supplied" do
+      ssh = Tenderloin.config.ssh
+      Kernel.expects(:exec).with("#{@script} #{ssh[:username]} #{ssh[:password]} #{ssh[:host]} #{Tenderloin::SSH.port}")
+      Tenderloin::SSH.connect
+    end
+
+    test "should call exec with supplied params" do
+      args = {:username => 'bar', :password => 'baz', :host => 'bak', :port => 'bag'}
+      Kernel.expects(:exec).with("#{@script} #{args[:username]} #{args[:password]} #{args[:host]} #{args[:port]}")
+      Tenderloin::SSH.connect(args)
+    end
+  end
+
+  context "executing ssh commands" do
+    should "call net::ssh.start with the proper names" do
+      Net::SSH.expects(:start).once.with() do |host, username, opts|
+        assert_equal Tenderloin.config.ssh.host, host
+        assert_equal Tenderloin.config.ssh.username, username
+        assert_equal Tenderloin::SSH.port, opts[:port]
+        assert_equal Tenderloin.config.ssh.password, opts[:password]
+        true
+      end
+      Tenderloin::SSH.execute
+    end
+
+    should "use custom host if set" do
+      Tenderloin.config.ssh.host = "foo"
+      Net::SSH.expects(:start).with(Tenderloin.config.ssh.host, Tenderloin.config.ssh.username, anything).once
+      Tenderloin::SSH.execute
+    end
+  end
+
+  context "SCPing files to the remote host" do
+    should "use Tenderloin::SSH execute to setup an SCP connection and upload" do
+      scp = mock("scp")
+      ssh = mock("ssh")
+      scp.expects(:upload!).with("foo", "bar").once
+      Net::SCP.expects(:new).with(ssh).returns(scp).once
+      Tenderloin::SSH.expects(:execute).yields(ssh).once
+      Tenderloin::SSH.upload!("foo", "bar")
+    end
+  end
+
+  context "checking if host is up" do
+    setup do
+      mock_config
+    end
+
+    should "return true if SSH connection works" do
+      Net::SSH.expects(:start).yields("success")
+      assert Tenderloin::SSH.up?
+    end
+
+    should "return false if SSH connection times out" do
+      Net::SSH.expects(:start)
+      assert !Tenderloin::SSH.up?
+    end
+
+    should "allow the thread the configured timeout time" do
+      @thread = mock("thread")
+      @thread.stubs(:[])
+      Thread.expects(:new).returns(@thread)
+      @thread.expects(:join).with(Tenderloin.config.ssh.timeout).once
+      Tenderloin::SSH.up?
+    end
+
+    should "return false if the connection is refused" do
+      Net::SSH.expects(:start).raises(Errno::ECONNREFUSED)
+      assert_nothing_raised {
+        assert !Tenderloin::SSH.up?
+      }
+    end
+
+    should "return false if the connection is dropped" do
+      Net::SSH.expects(:start).raises(Net::SSH::Disconnect)
+      assert_nothing_raised {
+        assert !Tenderloin::SSH.up?
+      }
+    end
+  end
+
+  context "getting the ssh port" do
+    should "return the configured port by default" do
+      assert_equal Tenderloin.config.vm.forwarded_ports[Tenderloin.config.ssh.forwarded_port_key][:hostport], Tenderloin::SSH.port
+    end
+
+    should "return the port given in options if it exists" do
+      assert_equal "47", Tenderloin::SSH.port({ :port => "47" })
+    end
+  end
+end

data/test/tenderloin/util_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class UtilTest < Test::Unit::TestCase
+  class RegUtil
+    extend Tenderloin::Util
+  end
+
+  context "erroring" do
+    # TODO: Any way to stub Kernel.exit? Can't test nicely
+    # otherwise
+  end
+
+  context "logger" do
+    class OtherUtil
+      extend Tenderloin::Util
+    end
+
+    setup do
+      @config = Tenderloin::Config::Top.new
+      @config.stubs(:loaded?).returns(true)
+      @config.tenderloin.log_output = STDOUT
+      Tenderloin::Config.stubs(:config).returns(@config)
+      Tenderloin::Logger.reset_logger!
+    end
+
+    teardown do
+      Tenderloin::Logger.reset_logger!
+    end
+
+    should "return a logger to nil if config is not loaded" do
+      @config.expects(:loaded?).returns(false)
+      logger = RegUtil.logger
+      assert_nil logger.instance_variable_get(:@logdev)
+    end
+
+    should "return a logger using the configured output" do
+      logger = RegUtil.logger
+      logdev = logger.instance_variable_get(:@logdev)
+      assert logger
+      assert !logdev.nil?
+      assert_equal STDOUT, logdev.dev
+    end
+
+    should "only instantiate a logger once" do
+      Tenderloin::Logger.expects(:new).once.returns("GOOD")
+      RegUtil.logger
+      RegUtil.logger
+    end
+
+    should "be able to reset the logger" do
+      Tenderloin::Logger.expects(:new).twice
+      RegUtil.logger
+      Tenderloin::Logger.reset_logger!
+      RegUtil.logger
+    end
+
+    should "return the same logger across classes" do
+      logger = RegUtil.logger
+      other = OtherUtil.logger
+
+      assert logger.equal?(other)
+    end
+  end
+end

data/test/tenderloin/vm_test.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class VMTest < Test::Unit::TestCase
+  setup do
+    @mock_vm = mock("vm")
+    mock_config
+
+    @persisted_vm = mock("persisted_vm")
+    Tenderloin::Env.stubs(:persisted_vm).returns(@persisted_vm)
+
+    Net::SSH.stubs(:start)
+  end
+
+  context "being an action runner" do
+    should "be an action runner" do
+      vm = Tenderloin::VM.new
+      assert vm.is_a?(Tenderloin::Actions::Runner)
+    end
+  end
+
+  context "finding a VM" do
+    should "return nil if the VM is not found" do
+      VirtualBox::VM.expects(:find).returns(nil)
+      assert_nil Tenderloin::VM.find("foo")
+    end
+
+    should "return a Tenderloin::VM object for that VM otherwise" do
+      VirtualBox::VM.expects(:find).with("foo").returns("bar")
+      result = Tenderloin::VM.find("foo")
+      assert result.is_a?(Tenderloin::VM)
+      assert_equal "bar", result.vm
+    end
+  end
+
+  context "tenderloin VM instance" do
+    setup do
+      @vm = Tenderloin::VM.new(@mock_vm)
+    end
+
+    context "packaging" do
+      should "queue up the actions and execute" do
+        out_path = mock("out_path")
+        action_seq = sequence("actions")
+        @vm.expects(:add_action).with(Tenderloin::Actions::VM::Export).once.in_sequence(action_seq)
+        @vm.expects(:add_action).with(Tenderloin::Actions::VM::Package, out_path, []).once.in_sequence(action_seq)
+        @vm.expects(:execute!).in_sequence(action_seq)
+        @vm.package(out_path)
+      end
+    end
+
+    context "destroying" do
+      should "execute the down action" do
+        @vm.expects(:execute!).with(Tenderloin::Actions::VM::Down).once
+        @vm.destroy
+      end
+    end
+
+    context "suspending" do
+      should "execute the suspend action" do
+        @vm.expects(:execute!).with(Tenderloin::Actions::VM::Suspend).once
+        @vm.suspend
+      end
+    end
+
+    context "resuming" do
+      should "execute the resume action" do
+        @vm.expects(:execute!).with(Tenderloin::Actions::VM::Resume).once
+        @vm.resume
+      end
+    end
+
+    context "starting" do
+      setup do
+        @mock_vm.stubs(:running?).returns(false)
+      end
+
+      should "not do anything if the VM is already running" do
+        @mock_vm.stubs(:running?).returns(true)
+        @vm.expects(:execute!).never
+        @vm.start
+      end
+
+      should "execute the start action" do
+        @vm.expects(:execute!).once.with(Tenderloin::Actions::VM::Start)
+        @vm.start
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,92 @@
+begin
+  require File.expand_path('../.bundle/environment', __FILE__)
+rescue LoadError
+  # Fallback on doing the resolve at runtime.
+  require "rubygems"
+  require "bundler"
+  Bundler.setup
+end
+
+# ruby-debug, not necessary, but useful if we have it
+begin
+  require 'ruby-debug'
+rescue LoadError; end
+
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'tenderloin')
+require 'contest'
+require 'mocha'
+
+class Test::Unit::TestCase
+  # Clears the previous config and sets up the new config
+  def mock_config
+    Tenderloin::Config.instance_variable_set(:@config_runners, nil)
+    Tenderloin::Config.instance_variable_set(:@config, nil)
+
+    Tenderloin::Config.run do |config|
+      config.tenderloin.dotfile_name = ".hobo"
+
+      config.ssh.username = "foo"
+      config.ssh.password = "bar"
+      config.ssh.host = "baz"
+      config.ssh.forwarded_port_key = "ssh"
+      config.ssh.max_tries = 10
+      config.ssh.timeout = 10
+
+      config.vm.box = "foo"
+      config.vm.box_ovf = "box.ovf"
+      config.vm.base_mac = "42"
+      config.vm.project_directory = "/hobo"
+      config.vm.disk_image_format = 'VMDK'
+      config.vm.forward_port("ssh", 22, 2222)
+
+      config.package.name = 'tenderloin'
+      config.package.extension = '.box'
+
+      config.chef.cookbooks_path = "cookbooks"
+      config.chef.provisioning_path = "/tmp/hobo-chef"
+      config.chef.json = {
+        :recipes => ["hobo_main"]
+      }
+
+      config.tenderloin.home = '~/.home'
+    end
+
+    if block_given?
+      Tenderloin::Config.run do |config|
+        yield config
+      end
+    end
+
+    if block_given?
+      Tenderloin::Config.run do |config|
+        yield config
+      end
+    end
+
+    Tenderloin::Config.execute!
+  end
+
+  # Sets up the mocks and instantiates an action for testing
+  def mock_action(action_klass, *args)
+    vm = mock("vboxvm")
+    mock_vm = mock("vm")
+    action = action_klass.new(mock_vm, *args)
+
+    mock_vm.stubs(:vm).returns(vm)
+    mock_vm.stubs(:vm=)
+    mock_vm.stubs(:invoke_callback)
+    mock_vm.stubs(:invoke_around_callback).yields
+    mock_vm.stubs(:actions).returns([action])
+
+    [mock_vm, vm, action]
+  end
+
+  # Sets up the mocks and stubs for a downloader
+  def mock_downloader(downloader_klass)
+    tempfile = mock("tempfile")
+    tempfile.stubs(:write)
+
+    [downloader_klass.new, tempfile]
+  end
+end