vagrant 0.5.4 → 0.6.0

data/templates/unison/crontab_entry.erb

@@ -1 +0,0 @@
-* * * * * <%= script %> '<%= from %>' '<%= to %>' '<%= options %>' >> <%= log_file %> 2>&1

data/templates/unison/script.erb

@@ -1,71 +0,0 @@
-#!/bin/bash
-#------------------------------------------------------------
-# Author       : John Bender and Mitchell Hashimoto
-# Description  : Runs the `unison` folder synchronization
-#                utility for shared folders.
-#------------------------------------------------------------
-
-#------------------------------------------------------------
-# Argument verification
-#------------------------------------------------------------
-if [ $# -ne 3 ]; then
-    echo "Usage: `basename $0` from_folder to_folder options"
-    exit 1
-fi
-
-# Sanitization function which turns any non-alphanumeric char
-# into a dash '-' and returns it by echoing the result.
-function sanitize() {
-    local DATA=$1
-    DATA=${DATA//[^a-zA-Z0-9_-]/-}
-    echo ${DATA}
-}
-
-#------------------------------------------------------------
-# "Configuration"
-#------------------------------------------------------------
-# TODO Change lockfile to depend on the from/to folder to
-# allow multiple syncs of diff folders to happen at once.
-FROM=$1
-TO=$2
-OPTIONS=$3
-LOCK_FILE=`basename $0`-$(sanitize ${TO}).lck
-
-#------------------------------------------------------------
-# Am I Running?
-#------------------------------------------------------------
-if [ -f "${LOCK_FILE}" ]; then
-    # The file exists, verify its running and if so exit.
-    OUR_PID=`head -n 1 "${LOCK_FILE}"`
-    TEST_RUNNING=`ps -p ${OUR_PID} | grep ${OUR_PID}`
-
-    if [ "${TEST_RUNNING}" ]; then
-        # The process is running, echo and exit.
-        echo "Unison sync already running. [PID: ${OUR_PID}]"
-        exit 0
-    fi
-fi
-
-# We're not running if we reached this point, so lock
-# it up.
-echo $$ > "${LOCK_FILE}"
-
-#------------------------------------------------------------
-# The Meat
-#------------------------------------------------------------
-echo "Beginning Sync:"
-echo " -- From: ${FROM}"
-echo " -- To: ${TO}"
-echo " -- Options: ${OPTIONS}"
-while [ 1 ]; do
-  echo "Syncing: $(date)"
-  # TODO check result and output log data... somewhere!
-  sudo unison ${FROM} ${TO} ${OPTIONS}
-  sleep 1
-done
-
-#------------------------------------------------------------
-# Cleanup and Exit
-#------------------------------------------------------------
-rm -f "${LOCK_FILE}"
-exit 0

data/test/vagrant/action/env/error_halt_test.rb

@@ -1,21 +0,0 @@
-require "test_helper"
-
-class ErrorHaltEnvActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::Env::ErrorHalt
-    @app, @env = mock_action_data
-    @instance = @klass.new(@app, @env)
-  end
-
-  should "continue the chain if no error" do
-    assert !@env.error?
-    @app.expects(:call).with(@env).once
-    @instance.call(@env)
-  end
-
-  should "halt the chain if an error occured" do
-    @env.error!(:foo)
-    @app.expects(:call).never
-    @instance.call(@env)
-  end
-end

data/test/vagrant/action/exception_catcher_test.rb

@@ -1,30 +0,0 @@
-require "test_helper"
-
-class ExceptionCatcherTest < Test::Unit::TestCase
-  setup do
-    @klass = Class.new
-    @klass.send(:include, Vagrant::Action::ExceptionCatcher)
-    @env = Vagrant::Action::Environment.new(mock_environment)
-
-    @instance = @klass.new
-  end
-
-  should "run block and return result if no exception" do
-    result = @instance.catch_action_exception(@env) do
-      true
-    end
-
-    assert result
-    assert !@env.error?
-  end
-
-  should "run block and return false with error environment on exception" do
-    result = @instance.catch_action_exception(@env) do
-      raise Vagrant::Action::ActionException.new(:foo, :foo => :bar)
-    end
-
-    assert !result
-    assert @env.error?
-    assert_equal :foo, @env.error.first
-  end
-end

data/test/vagrant/action/vm/persist_test.rb

@@ -1,50 +0,0 @@
-require "test_helper"
-
-class PersistVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::VM::Persist
-    @app, @env = mock_action_data
-
-    @vm = mock("vm")
-    @vm.stubs(:uuid).returns("123")
-    @env["vm"] = @vm
-  end
-
-  context "initializing" do
-    setup do
-      File.stubs(:file?).returns(true)
-      File.stubs(:exist?).returns(true)
-      @dotfile_path = "foo"
-      @env.env.stubs(:dotfile_path).returns(@dotfile_path)
-    end
-
-    should "error environment if dotfile exists but is not a file" do
-      File.expects(:file?).with(@env.env.dotfile_path).returns(false)
-      @klass.new(@app, @env)
-      assert @env.error?
-      assert_equal :dotfile_error, @env.error.first
-    end
-
-    should "initialize properly if dotfiles doesn't exist" do
-      File.expects(:exist?).with(@env.env.dotfile_path).returns(false)
-      @klass.new(@app, @env)
-      assert !@env.error?
-    end
-  end
-
-  context "with an instance" do
-    setup do
-      File.stubs(:file?).returns(true)
-      File.stubs(:exist?).returns(true)
-      @instance = @klass.new(@app, @env)
-    end
-
-    should "persist the dotfile then continue chain" do
-      update_seq = sequence("update_seq")
-      @env.env.expects(:update_dotfile).in_sequence(update_seq)
-      @app.expects(:call).with(@env).in_sequence(update_seq)
-
-      @instance.call(@env)
-    end
-  end
-end

data/test/vagrant/active_list_test.rb

@@ -1,173 +0,0 @@
-require "test_helper"
-
-class ActiveListTest < Test::Unit::TestCase
-  setup do
-    @env = mock_environment
-    @list = Vagrant::ActiveList.new(@env)
-  end
-
-  context "initializing" do
-    should "set the environment to nil if not specified" do
-      assert_nothing_raised {
-        list = Vagrant::ActiveList.new
-        assert list.env.nil?
-      }
-    end
-
-    should "set the environment to the given parameter if specified" do
-      env = mock("env")
-      list = Vagrant::ActiveList.new(env)
-      assert_equal env, list.env
-    end
-  end
-
-  context "listing" do
-    setup do
-      @path = "foo"
-      @list.stubs(:path).returns(@path)
-    end
-
-    should "load if reload is given" do
-      File.stubs(:file?).returns(true)
-      File.expects(:open).once
-      @list.list(true)
-    end
-
-    should "not load if the active json file doesn't exist" do
-      File.expects(:file?).with(@list.path).returns(false)
-      File.expects(:open).never
-      assert_equal Hash.new, @list.list(true)
-    end
-
-    should "parse the JSON by reading the file" do
-      file = mock("file")
-      data = mock("data")
-      result = { :hey => :yep }
-      File.expects(:file?).returns(true)
-      File.expects(:open).with(@list.path, 'r').once.yields(file)
-      file.expects(:read).returns(data)
-      JSON.expects(:parse).with(data).returns(result)
-      assert_equal result, @list.list(true)
-    end
-
-    should "not load if reload flag is false and already loaded" do
-      File.expects(:file?).once.returns(false)
-      result = @list.list(true)
-      assert result.equal?(@list.list)
-      assert result.equal?(@list.list)
-      assert result.equal?(@list.list)
-    end
-
-    should "be an empty hash if JSON parsing raises an exception" do
-      file = mock("file")
-      file.stubs(:read)
-      File.expects(:file?).returns(true)
-      File.expects(:open).with(@list.path, 'r').once.yields(file)
-      JSON.expects(:parse).raises(Exception)
-
-      assert_nothing_raised do
-        assert_equal Hash.new, @list.list(true)
-      end
-    end
-  end
-
-  context "filter list" do
-    should "remove nonexistent VMs" do
-      list = {}
-      result = {}
-      5.times do |i|
-        vm = mock("vm#{i}")
-        vm.stubs(:uuid).returns(i)
-
-        list[vm.uuid] = {}
-
-        found_vm = i % 2 ? nil : vm
-        Vagrant::VM.stubs(:find).with(vm.uuid, @env).returns(found_vm)
-        results[vm.uuid] = {} if found_vm
-      end
-
-      @list.stubs(:list).returns(list)
-      assert_equal result, @list.filter_list
-    end
-  end
-
-  context "adding a VM to the list" do
-    setup do
-      @the_list = {}
-      @list.stubs(:list).returns(@the_list)
-      @list.stubs(:save)
-
-      @uuid = "foo"
-      @vm = mock("vm")
-      @vm.stubs(:uuid).returns(@uuid)
-    end
-
-    should "add the VMs UUID to the list" do
-      @list.add(@vm)
-      assert @the_list[@uuid]
-      assert @the_list[@uuid].is_a?(Hash)
-    end
-
-    should "save after adding" do
-      save_seq = sequence('save')
-      @the_list.expects(:[]=).in_sequence(save_seq)
-      @list.expects(:save).in_sequence(save_seq)
-      @list.add(@vm)
-    end
-  end
-
-  context "deleting a VM from the list" do
-    setup do
-      @the_list = ["bar"]
-      @list.stubs(:list).returns(@the_list)
-      @list.stubs(:save)
-
-      @uuid = "bar"
-      @vm = mock("vm")
-      @vm.stubs(:uuid).returns(@uuid)
-      @vm.stubs(:is_a?).with(Vagrant::VM).returns(true)
-    end
-
-    should "delete the uuid from the list of a VM" do
-      @list.remove(@vm)
-      assert @the_list.empty?
-    end
-
-    should "delete just the string if a string is given" do
-      @the_list << "zoo"
-      @list.remove("zoo")
-      assert !@the_list.include?("zoo")
-    end
-
-    should "save after removing" do
-      save_seq = sequence('save')
-      @the_list.expects(:delete).in_sequence(save_seq)
-      @list.expects(:save).in_sequence(save_seq)
-      @list.remove(@vm)
-    end
-  end
-
-  context "saving" do
-    setup do
-      @filtered = ["zoo"]
-      @list.stubs(:filter_list).returns(@filtered)
-    end
-
-    should "open the JSON path and save to it" do
-      file = mock("file")
-      File.expects(:open).with(@list.path, "w+").yields(file)
-      file.expects(:write).with(@filtered.to_json)
-      @list.save
-    end
-  end
-
-  context "path" do
-    setup do
-      @env.stubs(:home_path).returns("foo")
-    end
-
-    should "return the active file within the home path" do
-      assert_equal File.join(@env.home_path, Vagrant::ActiveList::FILENAME), @list.path
-    end
-  end
-end

data/test/vagrant/command_test.rb

@@ -1,53 +0,0 @@
-require "test_helper"
-
-class CommandTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Command
-  end
-
-  context "initializing" do
-    setup do
-      @env = mock("environment")
-    end
-
-    should "set the env attribute" do
-      @instance = @klass.new(@env)
-      assert_equal @env, @instance.env
-    end
-  end
-
-  context "class methods" do
-    context "executing" do
-      should "load the environment then send the command on commands" do
-        env = mock("env")
-        commands = mock("commands")
-        env.stubs(:commands).returns(commands)
-        Vagrant::Environment.expects(:load!).returns(env)
-        commands.expects(:subcommand).with(1,2,3).once
-
-        @klass.execute(1,2,3)
-      end
-    end
-  end
-
-  context "with an instance" do
-    setup do
-      @env = mock_environment
-      @instance = @klass.new(@env)
-    end
-
-    context "subcommands" do
-      setup do
-        @raw_name = :bar
-        @name = :foo
-        @instance.stubs(:camelize).with(@raw_name).returns(@name)
-      end
-
-      should "send the env, name, and args to the base class" do
-        args = [1,2,3]
-        Vagrant::Commands::Base.expects(:dispatch).with(@env, @name, *args)
-        @instance.subcommand(@name, *args)
-      end
-    end
-  end
-end

data/test/vagrant/commands/base_test.rb

@@ -1,139 +0,0 @@
-require "test_helper"
-
-class CommandsBaseTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Commands::Base
-  end
-
-  context "initializing" do
-    should "setup the env attribute" do
-      env = mock("env")
-      instance = @klass.new(env)
-      assert_equal env, instance.env
-    end
-  end
-
-  context "class methods" do
-    setup do
-      @env = mock_environment
-      @klass.subcommands.clear
-    end
-
-    context "registering commands" do
-      should "register commands" do
-        klass = mock("klass")
-        @klass.subcommand("init", klass)
-        assert_equal klass, @klass.subcommands["init"]
-      end
-    end
-
-    context "dispatching to subcommands" do
-      setup do
-        @command_klass = mock("klass")
-        @name = "init"
-        @klass.subcommand(@name, @command_klass)
-
-        @args = [1,2,3]
-      end
-
-      should "call dispatch on child if subcommand is found" do
-        @command_klass.expects(:dispatch).with(@env, *@args)
-        @klass.dispatch(@env, @name, *@args)
-      end
-
-      should "instantiate and execute when no subcommand is found" do
-        instance = mock("instance")
-        @klass.expects(:new).with(@env).returns(instance)
-        instance.expects(:execute).with(@args)
-        @klass.dispatch(@env, *@args)
-      end
-    end
-
-    context "descriptions" do
-      should "be able to set description" do
-        description = "The lazy fox yada yada"
-        @klass.description(description)
-        assert_equal description, @klass.description
-      end
-    end
-  end
-
-  context "instance methods" do
-    setup do
-      @env = mock_environment
-      @instance = @klass.new(@env)
-    end
-
-    context "executing" do
-      should "show version if flag is set" do
-        @instance.expects(:puts_version).once
-        @instance.expects(:show_help).never
-        @instance.execute(["--version"])
-      end
-
-      should "just print the help by default" do
-        @instance.expects(:puts_version).never
-        @instance.expects(:show_help).once
-        @instance.execute([])
-      end
-    end
-
-    context "all or single methods" do
-      should "call the single method if a name is given" do
-        name = "bar"
-        @instance.expects(:foo_single).with(name).once
-        @instance.all_or_single(["bar"], :foo)
-      end
-
-      should "call the single method for each VM if no name is given" do
-        vms = { :foo => nil, :bar => nil }
-        vms.keys.each do |name|
-          @instance.expects(:foo_single).with(name).once
-        end
-
-        @env.stubs(:vms).returns(vms)
-        @instance.all_or_single([], :foo)
-      end
-    end
-
-    context "getting the option parser" do
-      should "create it with the options spec if it hasn't been created yet" do
-        opts = mock("opts")
-        opts.stubs(:on)
-
-        result = mock("result")
-        OptionParser.expects(:new).yields(opts).returns(result)
-        @instance.expects(:options_spec).with(opts)
-
-        assert_equal result, @instance.option_parser(true)
-      end
-
-      should "not create it once its been created" do
-        result = mock("result")
-        OptionParser.expects(:new).once.returns(result)
-
-        assert_equal result, @instance.option_parser(true)
-        assert_equal result, @instance.option_parser
-        assert_equal result, @instance.option_parser
-      end
-    end
-
-    context "parsing options" do
-      setup do
-        @args = []
-
-        @options = mock("options")
-        @option_parser = mock("option_parser")
-
-        @instance.stubs(:option_parser).returns(@option_parser)
-        @instance.stubs(:options).returns(@options)
-      end
-
-      should "parse the options with the args" do
-        result = mock("result")
-        @option_parser.expects(:parse!).with(@args).once.returns(result)
-        assert_equal result, @instance.parse_options(@args)
-      end
-    end
-  end
-end