vagrant 0.1.4 → 0.2.0.pre

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

@@ -2,102 +2,107 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 
 class ProvisionActionTest < Test::Unit::TestCase
   setup do
-    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Provision)
-
-    Vagrant::SSH.stubs(:execute)
-    Vagrant::SSH.stubs(:upload!)
-
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Provision)
     mock_config
   end
 
-  context "shared folders" do
-    should "setup shared folder on VM for the cookbooks" do
-      File.expects(:expand_path).with(Vagrant.config.chef.cookbooks_path, Vagrant::Env.root_path).returns("foo")
-      @action.expects(:cookbooks_path).returns("bar")
-      assert_equal ["vagrant-provisioning", "foo", "bar"], @action.collect_shared_folders
+  context "initialization" do
+    should "have a nil provisioner by default" do
+      assert_nil @action.provisioner
     end
   end
 
-  context "cookbooks path" do
-    should "return the proper cookbook path" do
-      cookbooks_path = File.join(Vagrant.config.chef.provisioning_path, "cookbooks")
-      assert_equal cookbooks_path, @action.cookbooks_path
+  context "executing" do
+    should "do nothing if the provisioner is nil" do
+      @action.expects(:provisioner).returns(nil)
+      assert_nothing_raised { @action.execute! }
     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 #{Vagrant.config.ssh.username} #{Vagrant.config.chef.provisioning_path}")
-      Vagrant::SSH.expects(:execute).yields(ssh)
-      @action.chown_provisioning_folder
+    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 "generating and uploading json" do
-    def assert_json
-      Vagrant::SSH.expects(:upload!).with do |json, path|
-        data = JSON.parse(json.read)
-        yield data
-        true
+  context "preparing" do
+    context "with a nil provisioner" do
+      setup do
+        mock_config do |config|
+          config.vm.provisioner = nil
+        end
       end
 
-      @action.setup_json
+      should "not set a provisioner if set to nil" do
+        @action.prepare
+        assert_nil @action.provisioner
+      end
     end
 
-    should "merge in the extra json specified in the config" do
-      Vagrant.config.chef.json = { :foo => "BAR" }
-      assert_json do |data|
-        assert_equal "BAR", data["foo"]
+    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).returns(@instance)
+
+        mock_config do |config|
+          config.vm.provisioner = @klass
+        end
       end
-    end
 
-    should "add the directory as a special case to the JSON" do
-      assert_json do |data|
-        assert_equal Vagrant.config.vm.project_directory, data["vagrant"]["directory"]
+      should "set the provisioner to an instantiation of the class" do
+        @klass.expects(:new).once.returns(@instance)
+        assert_nothing_raised { @action.prepare }
+        assert_equal @instance, @action.provisioner
       end
-    end
 
-    should "add the config to the JSON" do
-      assert_json do |data|
-        assert_equal Vagrant.config.vm.project_directory, data["vagrant"]["config"]["vm"]["project_directory"]
+      should "call prepare on the instance" do
+        @instance.expects(:prepare).once
+        @action.prepare
       end
-    end
 
-    should "upload a StringIO to dna.json" do
-      StringIO.expects(:new).with(anything).returns("bar")
-      File.expects(:join).with(Vagrant.config.chef.provisioning_path, "dna.json").once.returns("baz")
-      Vagrant::SSH.expects(:upload!).with("bar", "baz").once
-      @action.setup_json
+      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
-  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 "#{Vagrant.config.chef.provisioning_path}"
-cookbook_path "#{@action.cookbooks_path}"
-config
+    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).returns(instance)
+        assert_nothing_raised { @action.prepare }
+        assert_equal instance, @action.provisioner
+      end
 
-      StringIO.expects(:new).with(expected_config).once
-      @action.setup_solo_config
-    end
+      should "raise an ActionException if its an unknown symbol" do
+        mock_config do |config|
+          config.vm.provisioner = :this_will_never_exist
+        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(Vagrant.config.chef.provisioning_path, "solo.rb").once.returns("bar")
-      Vagrant::SSH.expects(:upload!).with("foo", "bar").once
-      @action.setup_solo_config
-    end
-  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
 
-  context "running chef solo" do
-    should "cd into the provisioning directory and run chef solo" do
-      ssh = mock("ssh")
-      ssh.expects(:exec!).with("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json").once
-      Vagrant::SSH.expects(:execute).yields(ssh)
-      @action.run_chef_solo
+      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

@@ -8,7 +8,7 @@ class ReloadActionTest < Test::Unit::TestCase
 
   context "sub-actions" do
     setup do
-      @default_order = [Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Boot]
+      @default_order = [Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Boot]
       @vm.stubs(:running?).returns(false)
     end
 
@@ -33,7 +33,8 @@ class ReloadActionTest < Test::Unit::TestCase
 
     should "add in the provisioning step if enabled" do
       mock_config do |config|
-        config.chef.enabled = true
+        # Dummy provisioner to test
+        config.vm.provisioner = "foo"
       end
 
       @default_order.push(Vagrant::Actions::VM::Provision)

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

@@ -12,17 +12,58 @@ class SharedFoldersActionTest < Test::Unit::TestCase
     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
-    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)
+    setup do
+      File.stubs(:expand_path).returns("baz")
+    end
+
+    should "convert the vagrant config values into an array" do
+      mock_config do |config|
+        config.vm.shared_folders.clear
+        config.vm.share_folder("foo", "bar", "baz")
+      end
+
+      result = [["foo", "baz", "bar"]]
       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
+    should "expand the path of the host folder" do
+      File.expects(:expand_path).with("baz").once.returns("expanded_baz")
+
+      mock_config do |config|
+        config.vm.shared_folders.clear
+        config.vm.share_folder("foo", "bar", "baz")
+      end
+
+      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
+
+      @mock_vm.expects(:reload!).once.in_sequence(destroy_seq)
+      @action.clear_shared_folders
     end
   end
 
@@ -39,7 +80,7 @@ class SharedFoldersActionTest < Test::Unit::TestCase
       @vm.stubs(:shared_folders).returns(shared_folders)
       @vm.expects(:save).with(true).once
 
-      @action.before_boot
+      @action.create_metadata
     end
   end
 
@@ -78,7 +119,7 @@ class SharedFoldersActionTest < Test::Unit::TestCase
     end
 
     should "execute the proper mount command" do
-      @ssh.expects(:exec!).with("sudo mount -t vboxsf #{@name} #{@guestpath}").returns(@success_return)
+      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=#{Vagrant.config.ssh.username},gid=#{Vagrant.config.ssh.username} #{@name} #{@guestpath}").returns(@success_return)
       mount_folder
     end
 
@@ -113,5 +154,17 @@ class SharedFoldersActionTest < Test::Unit::TestCase
         mount_folder
       }
     end
+
+    should "add uid AND gid to mount" do
+      uid = "foo"
+      gid = "bar"
+      mock_config do |config|
+        config.vm.shared_folder_uid = uid
+        config.vm.shared_folder_gid = gid
+      end
+
+      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=#{uid},gid=#{gid} #{@name} #{@guestpath}").returns(@success_return)
+      mount_folder
+    end
   end
 end

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

@@ -10,7 +10,7 @@ class UpActionTest < Test::Unit::TestCase
     setup do
       File.stubs(:file?).returns(true)
       File.stubs(:exist?).returns(true)
-      @default_order = [Vagrant::Actions::VM::Import, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Boot]
+      @default_order = [Vagrant::Actions::VM::Import, Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Boot]
     end
 
     def setup_action_expectations
@@ -47,7 +47,7 @@ class UpActionTest < Test::Unit::TestCase
 
     should "add in the provisioning step if enabled" do
       mock_config do |config|
-        config.chef.enabled = true
+        config.vm.provisioner = "foo"
       end
 
       @default_order.push(Vagrant::Actions::VM::Provision)
@@ -78,8 +78,8 @@ class UpActionTest < Test::Unit::TestCase
 
   context "persisting" do
     should "persist the VM with Env" do
-      @vm.stubs(:uuid)
-      Vagrant::Env.expects(:persist_vm).with(@vm).once
+      @mock_vm.stubs(:uuid)
+      Vagrant::Env.expects(:persist_vm).with(@mock_vm).once
       @action.persist
     end
   end

data/test/vagrant/active_list_test.rb

@@ -0,0 +1,169 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ActiveListTest < Test::Unit::TestCase
+  setup do
+    mock_config
+  end
+
+  context "class methods" do
+    context "loading" do
+      should "load if reload is given" do
+        File.stubs(:file?).returns(true)
+        File.expects(:open).once
+        Vagrant::ActiveList.list(true)
+      end
+
+      should "not load if the active json file doesn't exist" do
+        File.expects(:file?).with(Vagrant::ActiveList.path).returns(false)
+        File.expects(:open).never
+        assert_equal [], Vagrant::ActiveList.list(true)
+      end
+
+      should "parse the JSON by reading the file" do
+        file = mock("file")
+        data = mock("data")
+        result = mock("result")
+        File.expects(:file?).returns(true)
+        File.expects(:open).with(Vagrant::ActiveList.path, 'r').once.yields(file)
+        file.expects(:read).returns(data)
+        JSON.expects(:parse).with(data).returns(result)
+        assert_equal result, Vagrant::ActiveList.list(true)
+      end
+
+      should "not load if reload flag is false and already loaded" do
+        File.expects(:file?).once.returns(false)
+        result = Vagrant::ActiveList.list(true)
+        assert result.equal?(Vagrant::ActiveList.list)
+        assert result.equal?(Vagrant::ActiveList.list)
+        assert result.equal?(Vagrant::ActiveList.list)
+      end
+    end
+
+    context "vms" do
+      setup do
+        @list = ["foo", "bar"]
+        Vagrant::ActiveList.stubs(:list).returns(@list)
+      end
+
+      should "return the list, but with each value as a VM" do
+        new_seq = sequence("new")
+        results = []
+        @list.each do |item|
+          result = mock("result-#{item}")
+          Vagrant::VM.expects(:find).with(item).returns(result).in_sequence(new_seq)
+          results << result
+        end
+
+        assert_equal results, Vagrant::ActiveList.vms
+      end
+
+      should "compact out the nil values" do
+        Vagrant::VM.stubs(:find).returns(nil)
+        results = Vagrant::ActiveList.vms
+        assert results.empty?
+      end
+    end
+
+    context "filtered list" do
+      should "return a list of UUIDs from the VMs" do
+        vms = []
+        result = []
+        5.times do |i|
+          vm = mock("vm#{i}")
+          vm.expects(:uuid).returns(i)
+          result << i
+          vms << vm
+        end
+
+        Vagrant::ActiveList.stubs(:vms).returns(vms)
+        assert_equal result, Vagrant::ActiveList.filtered_list
+      end
+    end
+
+    context "adding a VM to the list" do
+      setup do
+        @list = []
+        Vagrant::ActiveList.stubs(:list).returns(@list)
+        Vagrant::ActiveList.stubs(:save)
+
+        @uuid = "foo"
+        @vm = mock("vm")
+        @vm.stubs(:uuid).returns(@uuid)
+      end
+
+      should "add the VMs UUID to the list" do
+        Vagrant::ActiveList.add(@vm)
+        assert_equal [@uuid], @list
+      end
+
+      should "uniq the array so multiples never exist" do
+        @list << @uuid
+        assert_equal 1, @list.length
+        Vagrant::ActiveList.add(@vm)
+        assert_equal 1, @list.length
+      end
+
+      should "save after adding" do
+        save_seq = sequence('save')
+        @list.expects(:<<).in_sequence(save_seq)
+        Vagrant::ActiveList.expects(:save).in_sequence(save_seq)
+        Vagrant::ActiveList.add(@vm)
+      end
+    end
+
+    context "deleting a VM from the list" do
+      setup do
+        @list = ["bar"]
+        Vagrant::ActiveList.stubs(:list).returns(@list)
+        Vagrant::ActiveList.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
+        Vagrant::ActiveList.remove(@vm)
+        assert @list.empty?
+      end
+
+      should "delete just the string if a string is given" do
+        @list << "zoo"
+        Vagrant::ActiveList.remove("zoo")
+        assert !@list.include?("zoo")
+      end
+
+      should "save after removing" do
+        save_seq = sequence('save')
+        @list.expects(:delete).in_sequence(save_seq)
+        Vagrant::ActiveList.expects(:save).in_sequence(save_seq)
+        Vagrant::ActiveList.remove(@vm)
+      end
+    end
+
+    context "saving" do
+      setup do
+        @filtered = ["zoo"]
+        Vagrant::ActiveList.stubs(:filtered_list).returns(@filtered)
+      end
+
+      should "open the JSON path and save to it" do
+        file = mock("file")
+        File.expects(:open).with(Vagrant::ActiveList.path, "w+").yields(file)
+        file.expects(:write).with(@filtered.to_json)
+        Vagrant::ActiveList.save
+      end
+    end
+
+    context "path" do
+      setup do
+        Vagrant::Env.stubs(:home_path).returns("foo")
+      end
+
+      should "return the active file within the home path" do
+        assert_equal File.join(Vagrant::Env.home_path, Vagrant::ActiveList::FILENAME), Vagrant::ActiveList.path
+      end
+    end
+  end
+end