vagrant-babushka 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d8d6401a57d7fe37be1f75b453417e0bebfe344
-  data.tar.gz: ba4180b390bdbcea4612f3c05bf378b23bb0af86
+  metadata.gz: 0c21e99dc53da017ce744dbf00984705e537fa75
+  data.tar.gz: 5aa688d0cc3af642b21eacebeb4c07f193b864bc
 SHA512:
-  metadata.gz: 1d2a4980561b92ef73a65112896fd274e8523994620949eb9a04255eac5a54e97e105559ffee1b8bac1d45598d54a0b5b61e09ba750e9fd20d44759ae6ff7a55
-  data.tar.gz: 80bada052a188da60332fc2e3e1711e229eb391d4328c10324117e8f802d37d50ee2808798c0be658886834810168ea9303ba90fc166579018b318a98f9492fc
+  metadata.gz: 4ec88c85577ce6a0907153e08a347cd4c4e4a958b7a70c20da4f69cf1cd8d0f709f19727ecba563b03dcc74776a49d42b33af873d0b0de7952ce345ac1e92e6c
+  data.tar.gz: cc858b966ce45dceb6b23d9d7b37e195f7d70054492a35dc2d4b9eda73af6ae47166c159dad423236a21b0102ffafef5b3e39be49c4cdd83dd47db526cfb9a48

data/.gitignore

@@ -3,6 +3,7 @@
 .bundle
 .config
 .yardoc
+.rspec
 Gemfile.lock
 InstalledFiles
 _yardoc

data/README.md

@@ -10,6 +10,16 @@ Based on a [plugin concept][3] by @tcurdt.
 [3]: <https://github.com/tcurdt/vagrant-boxes/blob/master/plugins/babushka_provisioner.rb>
 
 
+## Requirements
+
+* Vagrant 1.1+
+* cURL on the virtual machine (will be installed if missing on Ubuntu)
+
+Note: The latest version of this plugin has only been tested on Ubuntu
+virtual machines. Please open a GitHub issue if it doesn't work for you
+or your operating system.
+
+
 ## Installation
 
 ```bash
@@ -25,6 +35,9 @@ Add a Babushka provision block to your project's Vagrantfile:
 config.vm.provision :babushka do |babushka|
   # Set the Git branch of Babushka to install on the guest (defaults to master)
   babushka.bootstrap_branch = 'master'
+  # ...or set the URL of the bootstrap script directly
+  babushka.bootstrap_url = 'https://example.com/babushka-bootstrap'
+
 
   # Share a directory of local Babushka deps with the VM
   # This example shares the '.deps/' directory (relative to this
@@ -32,6 +45,7 @@ config.vm.provision :babushka do |babushka|
   # directory of the main SSH user on the guest)
   babushka.local_deps_path = '.deps'
 
+
   # Meet a local dep
   # Assuming a dep named 'htop' is defined in a file under './.deps'
   babushka.meet 'htop'
@@ -40,9 +54,9 @@ config.vm.provision :babushka do |babushka|
   # Assuming source 'tcurdt' has a dep named 'rbenv system'
   babushka.meet 'rbenv system', :source => 'tcurdt'
 
-  # Also, you can set options for deps
+  # Also, you can set values for deps' parameters
   babushka.meet 'rbenv system', :params => {:key => "value"}
-  # or for remote dep
+  # ...and for remote deps:
   babushka.meet 'rbenv system', :source => 'tcurdt', :params => {:key => "value"}
 
 
@@ -56,8 +70,34 @@ config.vm.provision :babushka do |babushka|
   # Assuming source 'tcurdt' has a dep named 'rbenv system'
   babushka.remote_dep 'tcurdt', 'rbenv system'
 
-  # Also, you can set options for deps, using a hash as the third parameter
+  # Also, you can set values for deps' parameters, using a hash as the last parameter
   babushka.remote_dep 'tcurdt', 'rbenv system', :path => '/opt/rbenv'
+
+
+  # Set options for the Babushka run
+
+  # Enable/disable colorised (ANSI) output from Babushka
+  # The default value is inherited from Vagrant's current setting
+  babushka.color = true
+
+  # Enable Babushka's debug mode (defaults to false)
+  babushka.debug = true
+
+  # Only do a "dry run", don't meet any deps (defaults to false)
+  babushka.dry_run = true
+
+  # Show parameter values passed to deps (defaults to false)
+  babushka.show_args = true
+
+  # Enable silent mode, no output (defaults to false)
+  babushka.silent = true
+
+  # Enable/disable updating sources before running their deps (defaults to true)
+  babushka.update = false
+
+  # These options can be overridden on particular deps, for example:
+  babushka.meet 'rbenv system', :source => 'tcurdt', :update => false
+  babushka.meet 'htop', :color => false
 end
 ```
 
@@ -71,6 +111,12 @@ end
 5. Create new Pull Request
 
 
+## Testing
+
+1. `bundle install`
+2. `bundle exec rspec`
+
+
 ## Thanks
 
 [patcon](https://github.com/patcon)  

data/lib/vagrant-babushka/config.rb

@@ -2,15 +2,32 @@ module VagrantPlugins
   module Babushka
     # Main configuration object for Vagrant Babushka provisioner
     class Config < Vagrant.plugin("2", :config)
-      attr_accessor :args, :deps, :local_deps_path, :bootstrap_branch
+      # Configuration keys that are used as Babushka command-line args
+      ARGUMENTS = [
+        :color,
+        :debug,
+        :dry_run,
+        :show_args,
+        :silent,
+        :update,
+      ]
+
+      attr_accessor :deps, :local_deps_path, :bootstrap_branch, :bootstrap_url
       attr_reader :messages
 
+      # Command-line argument options
+      attr_accessor *ARGUMENTS
+
       def initialize
         super
         @deps = []
         @local_deps_path = UNSET_VALUE
         @bootstrap_branch = UNSET_VALUE
+        @bootstrap_url = UNSET_VALUE
         @messages = []
+
+        # Reset all argument values to UNSET_VALUE
+        ARGUMENTS.each {|a| self.send "#{a}=".to_sym, UNSET_VALUE }
       end
 
       # This is called as a last-minute hook that allows the
@@ -21,6 +38,29 @@ module VagrantPlugins
         @deps = [] if @deps == UNSET_VALUE
         @local_deps_path  = nil if @local_deps_path  == UNSET_VALUE
         @bootstrap_branch = nil if @bootstrap_branch == UNSET_VALUE
+
+        # Setup bootstrap URL if not set
+        if @bootstrap_url == UNSET_VALUE
+          @bootstrap_url = "https://babushka.me/up"
+          @bootstrap_url += "/#{@bootstrap_branch}" if @bootstrap_branch
+        end
+
+        # Set defaults for command-line arguments
+        @color = nil if @color == UNSET_VALUE
+        @debug = false if @debug == UNSET_VALUE
+        @dry_run = false if @dry_run == UNSET_VALUE
+        @show_args = false if @show_args == UNSET_VALUE
+        @silent = false if @silent == UNSET_VALUE
+        @update = true if @update == UNSET_VALUE
+      end
+
+      # Retrieves a Hash of the command-line argument config values
+      #
+      # The returned Hash will have command-line argument names for
+      # keys, and the value for the argument as the corresponding
+      # value.
+      def arguments
+        ARGUMENTS.inject(Hash.new) {|hash, key| hash.merge({key => send(key)}) }
       end
 
       # Meets a local dep on the guest

data/lib/vagrant-babushka/dep.rb

@@ -52,13 +52,13 @@ module VagrantPlugins
         @options[:params] || Hash.new
       end
 
-      # Creates a command string to use for this dep on the command line
+      # Retrieves the command-line arguments for the dep
       #
-      # This will return a string which can be used as an argument to
-      # "babushka meet" to meet this dep with its parameters.
-      def command
-        values = params.map {|k, v| "#{escape k}=#{escape v}" }
-        [escape(id), values].flatten.join(" ")
+      # This returns a hash including all the Babushka command-line
+      # arguments (to override the global settings) when meeting this
+      # dep.
+      def arguments
+        @options.select {|key, value| Config::ARGUMENTS.include? key }
       end
 
       def ==(other)
@@ -71,12 +71,6 @@ module VagrantPlugins
         def state
           [@dep_name, @options[:params], @options[:source]]
         end
-
-      private
-        # Alias for Shellwords.escape
-        def escape(string)
-          Shellwords.escape(string.to_s)
-        end
     end
   end
 end

data/lib/vagrant-babushka/plugin.rb

@@ -2,7 +2,7 @@ module VagrantPlugins
   module Babushka
     class Plugin < Vagrant.plugin("2")
       name "Babushka"
-      description <<-END
+      description <<-END.gsub(/ {6}|\n\Z/, "")
         Provides support for provisioning your virtual machines using
         Babushka.
       END

data/lib/vagrant-babushka/provisioner.rb

@@ -1,84 +1,248 @@
+require 'forwardable'
+
 module VagrantPlugins
   module Babushka
     # The main implementation class for the Babushka provisioner
     class Provisioner < Vagrant.plugin("2", :provisioner)
 
-      def initialize(machine, config)
-        super
+      # Exception raised if cURL isn't on the VM and can't be installed
+      class CurlMissing < Vagrant::Errors::VagrantError
+        error_message <<-END.gsub(/ {8}|\n\Z/, "")
+          cURL couldn't be found on the VM, and this plugin doesn't
+          know how to install it on the guest OS.
+
+          Try installing it manually, or consider adding the
+          functionality to the plugin and opening a pull request.
+        END
       end
 
+      # Allow delegation of methods to an accessor
+      extend Forwardable
+
+      # Delegate some methods to @machine (to reduce boilerplate)
+      delegate [:communicate, :env, :name] => :@machine
+      delegate :ui => :env
+
+      attr_accessor :username, :group
+
+      # Called with the root configuration of the machine so the
+      # provisioner can add some configuration on top of the machine.
+      #
+      # During this step, and this step only, the provisioner should
+      # modify the root machine configuration to add any additional
+      # features it may need. Examples include sharing folders,
+      # networking, and so on. This step is guaranteed to be called
+      # before any of those steps are done so the provisioner may do
+      # that.
       def configure(root_config)
         @username = root_config.ssh.username || root_config.ssh.default.username
-        @hostname = root_config.vm.hostname
-        if @config.local_deps_path
-          local_path = @config.local_deps_path
-          remote_path = "/home/#{@username}/babushka-deps"
-          opts = {id: 'babushka_deps', nfs: false}
-          root_config.vm.synced_folder local_path, remote_path, opts
-        end
+        share_local_deps(root_config) if config.local_deps_path
       end
 
       # This is the method called when the actual provisioning should
       # be done. The communicator is guaranteed to be ready at this
       # point, and any shared folders or networds are already set up.
       def provision
-        render_messages!
-        bootstrap_babushka! unless @machine.communicate.test('babushka --version')
-        @config.deps.map do |dep|
-          run_remote "babushka --update --defaults --color #{dep.command}"
+        detect_ssh_group
+        render_messages
+        prepare
+        do_babushka_run
+      end
+
+      # Shares local deps with the virtual machine
+      def share_local_deps(root_config)
+        local_path = config.local_deps_path
+        remote_path = "~#{escape username}/babushka-deps"
+        opts = {:id => 'babushka_deps', :nfs => false}
+        root_config.vm.synced_folder local_path, remote_path, opts
+      end
+
+      # Determines and saves the name of the SSH user's primary group
+      def detect_ssh_group
+        @group = ""
+
+        # Save stdout into @group
+        communicate.execute("id -gn #{escape username}") do |type, data|
+          @group += data if type == :stdout
         end
+
+        # Remove trailing newline from command output
+        @group.gsub! /\n\Z/, ""
       end
 
-      private
       # Renders the messages to the log output
       #
       # The config object maintains a list of "messages" to be shown
       # when provisioning occurs, since there's no way to show messages
       # at the time of configuration actually occurring. This displays
       # the messages that were saved.
-      def render_messages!
-        @config.messages.each do |(level, info, caller)|
+      def render_messages
+        config.messages.each do |(level, info, caller)|
           info = "vagrant-babushka: #{info}"
           info += "\nIn #{caller.first}" unless caller.nil?
-          @machine.env.ui.send level.to_sym, info.to_s, :scope => @machine.name
+          ui.send level.to_sym, info.to_s, :scope => name
         end
       end
 
-      # Installs Babushka on the guest using the bootstrap script
-      def bootstrap_babushka!
-        require 'net/http'
-        @machine.env.ui.info("Installing babushka on #{@hostname}.")
-        local_tmpfile = remote_tmpfile = "/tmp/babushka_me_up"
-        File.open(local_tmpfile, 'w') {|f| f.write `curl #{babushka_uri}` }
-        @machine.communicate.upload(local_tmpfile, remote_tmpfile)
-        run_remote "#{proxy_env} sh #{remote_tmpfile}"
+      # Performs preparation necessary before Babushka can be invoked
+      #
+      # Installs Babushka if it's not available. If Babushka needs to
+      # be installed, cURL will be installed first so that Babushka
+      # can be downloaded over HTTPS (as wget may not support HTTPS).
+      def prepare
+        unless in_path? "babushka"
+          # Install cURL first to ensure we can download over HTTPS
+          install_curl! unless in_path? "curl"
+          create_destination!
+          install_babushka!
+          ui.info "\n\n\n"
+        end
       end
 
-      # Extracts the HTTPS proxy from the host environment variables
-      def proxy_env
-        vars = ''
-        vars_from_env = ENV.select { |k, _| /https_proxy/i.match(k) }
-        vars = vars_from_env.to_a.map{ |pair| pair.join('=') }.join(' ') unless vars_from_env.empty?
-        vars
+      # Invokes Babushka on the virtual machine to meet requested deps
+      #
+      # Since Babushka can only meet one dep at a time, if multiple
+      # deps are in the meet list (the user has requested multiple
+      # deps to be run) then we have to have multiple invokations,
+      # once for each dep.
+      def do_babushka_run
+        if config.deps.empty?
+          ui.warn <<-END.gsub(/ {12}|\n\Z/, ""), :scope => name
+            Didn't find any Babushka deps to be met on the VM.
+            Add some to your Vagrantfile: babushka.meet 'my dep'
+          END
+        else
+          ui.info "Provisioning VM using Babushka...", :scope => name
+          config.deps.each do |dep|
+            ui.info "Meeting Babushka dep '#{dep.id}'", :scope => name
+            ui.info "Executing '#{command_for(dep).strip}'...", :scope => name
+            communicate.execute command_for(dep), &log_stdout
+          end
+        end
       end
 
-      # Retrieves the URL to use to bootstrap Babushka on the guest
-      def babushka_uri
-        uri = 'https://babushka.me/up'
-        uri = "#{uri}/#{@config.bootstrap_branch}" unless @config.bootstrap_branch.nil?
-        uri
-      end
+      private
+        # Determines if the virtual machine has a command in its $PATH
+        #
+        #   command: The name of the command to look for
+        def in_path?(command)
+          communicate.test("which #{escape command}").tap do |result|
+            if result
+              ui.info "'#{command}' found on guest", :scope => name
+            end
+          end
+        end
 
-      # Executes a command on the guest and handles logging the output
-      #
-      #   * command: The command to execute (as a string)
-      def run_remote(command)
-        @machine.communicate.sudo(command) do |type, data|
-          color = type == :stdout ? :green : :red
-          @machine.env.ui.info(data.chomp, :color => color, :prefix => false)
+        # Installs cURL on the virtual machine
+        def install_curl!
+          raise CurlMissing.new unless in_path? "apt-get"
+          ui.info "Installing cURL package on VM...", :scope => name
+          communicate.sudo "apt-get --quiet --assume-yes install curl"
+        end
+
+        # Creates the Babushka installation directory on the VM
+        #
+        # This will create the directory (as root), then set up the
+        # permissions on it to belong to the SSH user's primary group,
+        # and give the group read and write privileges. The permissions
+        # are also adjusted on /usr/local/bin, so Babushka can symlink
+        # itself into the PATH.
+        def create_destination!
+          ui.info "Creating Babushka directory...", :scope => name
+          communicate.sudo [
+            # Create directory, and parent directories if also missing
+            "mkdir -p /usr/local/babushka",
+
+            # Change Babushka directory's group to user's primary group
+            "chgrp #{escape group} /usr/local/babushka /usr/local/bin",
+
+            # Add read/write privileges where Babushka needs them
+            "chmod g+rw /usr/local/babushka /usr/local/bin",
+          ].join(" && ")
         end
-      end
 
+        # Installs Babushka on the virtual machine
+        def install_babushka!
+          ui.info <<-END.gsub(/ {12}|\n\Z/, ""), :scope => name
+            Installing Babushka via bootstrap script at \
+            #{config.bootstrap_url}...
+          END
+
+          unless config.bootstrap_url =~ %r[^https://]
+            ui.warn "WARNING: Using non-SSL source", :scope => name
+          end
+
+          # Log stdout straight to Vagrant's output
+          communicate.execute install_babushka_command, &log_stdout
+        end
+
+        # The command used to install Babushka on the virtual machine
+        def install_babushka_command
+          %Q[#{vars} sh -c "`#{vars} curl #{escape config.bootstrap_url}`"]
+        end
+
+        # Retrieves the environment variables to use for VM commands
+        #
+        # Extracts the HTTPS proxy from the host environment variables
+        #
+        # Returns a string that can be used as a prefix to a command in
+        # order to assign the variables for that command.
+        def vars
+          proxy_env = ENV.select {|k, _| /https_proxy/i.match(k) }
+          proxy_env.map{|k, v| "#{escape k}=#{escape v}" }.join(" ")
+        end
+
+        # A block that logs stdout, when passed to a communicator
+        #
+        #   type: The stream where the output in data came from, one of
+        #         :stdout or :stderr
+        #   data: The echoed data as a string
+        def log_stdout
+          lambda do |type, data|
+            ui.info data, :new_line => false if type == :stdout
+          end
+        end
+
+        # Creates a command string to use for a dep on the command line
+        #
+        # This will return a string which can be used as a command to
+        # run Babushka to meet a particular dep.
+        #
+        #   * dep: The Dep to generate the command string for
+        def command_for(dep)
+          [
+            vars, "babushka", "meet",
+            args_for(dep),  # Babushka command-line arguments
+            escape(dep.id), # Identifier for the dep to be met
+            dep.params.map {|k, v| "#{escape k}=#{escape v}" },
+          ].flatten.join(" ")
+        end
+
+        # Generates the Babushka command-line arguments for a dep
+        #
+        # Given a dep, this method merges the configuration options for
+        # the specific dep with the configuration of the provisioner as
+        # "defaults" if values aren't set on the dep itself.
+        #
+        #   * dep: The Dep to generate the command string for
+        def args_for(dep)
+          result = config.arguments.merge(dep.arguments)
+          result[:color] = ui.is_a? Vagrant::UI::Colored if result[:color].nil?
+          [
+            '--defaults', # Must use defaults -- stdin not connected
+            result[:color]     ? '--color'     : '--no-color',
+            result[:debug]     ? '--debug'     : nil,
+            result[:dry_run]   ? '--dry-run'   : nil,
+            result[:show_args] ? '--show-args' : nil,
+            result[:silent]    ? '--silent'    : nil,
+            result[:update]    ? '--update'    : nil,
+          ].compact.join(" ") # Remove nil values and concatenate
+        end
+
+        # Alias for Shellwords.escape
+        def escape(string)
+          Shellwords.escape(string.to_s)
+        end
     end
   end
 end

data/lib/vagrant-babushka/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Babushka
-    VERSION = "0.0.7"
+    VERSION = "0.1.0"
   end
 end

data/spec/unit/vagrant-babushka/config_spec.rb

@@ -3,28 +3,63 @@ require "spec_helper"
 describe VagrantPlugins::Babushka::Config do
   let(:unset_value) { described_class::UNSET_VALUE }
   let(:config) { described_class.new }
+  subject { config }
 
   context "with default configuration" do
-    before { subject.finalize! }
+    before { config.finalize! }
     its(:deps) { should eq [] }
     its(:local_deps_path) { should be_nil }
     its(:bootstrap_branch) { should be_nil }
   end
 
   describe "#local_deps_path" do
-    before { subject.local_deps_path = '.deps' }
+    before { config.local_deps_path = '.deps'; config.finalize! }
     its(:local_deps_path) { should eq '.deps' }
   end
 
   describe "#bootstrap_branch" do
-    before { subject.bootstrap_branch = 'new' }
+    before { config.bootstrap_branch = 'new'; config.finalize! }
     its(:bootstrap_branch) { should eq 'new' }
+    its(:bootstrap_url) { should eq 'https://babushka.me/up/new' }
+  end
+
+  describe "#bootstrap_url" do
+    before do
+      config.bootstrap_url = 'https://example.com/foo'
+      config.finalize!
+    end
+
+    its(:bootstrap_url) { should eq 'https://example.com/foo' }
+  end
+
+  describe "#arguments" do
+    before do
+      config.color = false
+      config.debug = true
+      config.dry_run = true
+      config.bootstrap_url = double "bootstrap_url"
+      config.finalize!
+    end
+
+    subject { config.arguments }
+
+    specify "set values should override defaults" do
+      expect(subject).to eq({
+        :color => false,
+        :debug => true,
+        :dry_run => true,
+        :show_args => false,
+        :silent => false,
+        :update => true,
+      })
+    end
   end
 
   describe "#local_dep" do
     before do
-      subject.local_dep 'foobar', :baz => :qux
-      subject.local_dep 'testme', :one => :two
+      config.local_dep 'foobar', :baz => :qux
+      config.local_dep 'testme', :one => :two
+      config.finalize!
     end
 
     it "should store the deps correctly" do
@@ -37,8 +72,9 @@ describe VagrantPlugins::Babushka::Config do
 
   describe "#remote_dep" do
     before do
-      subject.remote_dep 'user1', 'foobar', :baz => :qux
-      subject.remote_dep 'user2', 'testme', :one => :two
+      config.remote_dep 'user1', 'foobar', :baz => :qux
+      config.remote_dep 'user2', 'testme', :one => :two
+      config.finalize!
     end
 
     it "should store the deps correctly" do
@@ -51,8 +87,9 @@ describe VagrantPlugins::Babushka::Config do
 
   describe "#meet" do
     before {
-      subject.meet 'test1', :source => 'user1', :params => {:abc => :def}
-      subject.meet 'test2', :source => 'user2', :params => {:ghi => :jkl}
+      config.meet 'test1', :source => 'user1', :params => {:abc => :def}
+      config.meet 'test2', :source => 'user2', :params => {:ghi => :jkl}
+      config.finalize!
     }
 
     it "should store the deps correctly" do

data/spec/unit/vagrant-babushka/dep_spec.rb

@@ -21,11 +21,6 @@ describe VagrantPlugins::Babushka::Dep do
     it { should be_nil }
   end
 
-  describe "#command" do
-    subject { dep.command }
-    it { should eq "the\\ dep" }
-  end
-
   context "with source" do
     let(:options) { {:source => source} }
     let(:source) { double "source", :to_s => "the source" }
@@ -39,11 +34,6 @@ describe VagrantPlugins::Babushka::Dep do
       subject { dep.source }
       it { should eq source.to_s }
     end
-
-    describe "#command" do
-      subject { dep.command }
-      it { should eq "the\\ source:the\\ dep" }
-    end
   end
 
   context "with params" do
@@ -52,22 +42,18 @@ describe VagrantPlugins::Babushka::Dep do
 
     describe "#params" do
       subject { dep.params }
-    end
-
-    describe "#command" do
-      subject { dep.command }
-      it { should eq "the\\ dep foo=bar baz=qux" }
+      it { should be params }
     end
   end
 
-  context "with source and params" do
-    let(:options) { {:params => params, :source => source} }
-    let(:params) { {:foo => :bar, :baz => :qux} }
-    let(:source) { double "source", :to_s => "the source" }
+  context "with arguments" do
+    let(:options) { {:color => color, :source => source} }
+    let(:color) { double "color" }
+    let(:source) { double "source" }
 
-    describe "#command" do
-      subject { dep.command }
-      it { should eq "the\\ source:the\\ dep foo=bar baz=qux" }
+    describe "#arguments" do
+      subject { dep.arguments }
+      it { should eq({:color => color})  }
     end
   end
 end

data/spec/unit/vagrant-babushka/provisioner_spec.rb

@@ -0,0 +1,122 @@
+require "spec_helper"
+
+describe VagrantPlugins::Babushka::Provisioner do
+  let(:config) { double "config" }
+  let(:machine) { double "machine", :name => "the name", :communicate => communicate, :env => env }
+  let(:communicate) { double "communicate" }
+  let(:env) { double "env", :ui => ui }
+  let(:ui) { double "ui" }
+  let(:provisioner) { described_class.new machine, config }
+  subject { provisioner }
+
+  describe "#share_local_deps" do
+    let(:root_config) { double "root config", :vm => vm }
+    let(:config) { double "config", :local_deps_path => local_deps_path }
+    let(:local_deps_path) { double "local deps path", :to_s => "the local deps" }
+    let(:vm) { double "root config.vm" }
+
+    it "should configure the directory to be shared" do
+      expect(config).to receive(:local_deps_path).and_return(local_deps_path)
+      expect(vm).to receive(:synced_folder).with(local_deps_path, "~the\\ user/babushka-deps", {:id => 'babushka_deps', :nfs => false})
+      provisioner.username = double "username", :to_s => "the user"
+      provisioner.share_local_deps root_config
+      subject
+    end
+  end
+
+  describe "#detect_ssh_group" do
+    let(:username) { double "username", :to_s => 'the user' }
+
+    before do
+      provisioner.username = username
+      expect(communicate).to receive(:execute).with("id -gn the\\ user").and_yield(:stdout, "test\n")
+      subject.detect_ssh_group
+    end
+
+    its(:group) { should eq "test" }
+  end
+
+  describe "#render_messages" do
+    let(:config) { double "config", :messages => messages }
+    let(:messages) do
+      [
+        [:warn, "foo bar baz"],
+        [:info, "one two three", ['file x line y']],
+      ]
+    end
+
+    it "should output the mesages" do
+      expect(ui).to receive(:send).with(:warn, "vagrant-babushka: foo bar baz", :scope => "the name")
+      expect(ui).to receive(:send).with(:info, "vagrant-babushka: one two three\nIn file x line y", :scope => "the name")
+      subject.render_messages
+    end
+  end
+
+  describe "#prepare" do
+    context "with Babushka not yet installed" do
+      it "should install cURL and Babushka" do
+        expect(provisioner).to receive(:in_path?).with("babushka").and_return(false)
+        expect(provisioner).to receive(:in_path?).with("curl").and_return(false)
+        expect(provisioner).to receive(:install_curl!)
+        expect(provisioner).to receive(:create_destination!)
+        expect(provisioner).to receive(:install_babushka!)
+        expect(ui).to receive(:info).with("\n\n\n")
+        subject.prepare
+      end
+
+      context "with cURL already installed" do
+        it "should install Babushka" do
+          expect(provisioner).to receive(:in_path?).with("babushka").and_return(false)
+          expect(provisioner).to receive(:in_path?).with("curl").and_return(true)
+          expect(provisioner).to_not receive(:install_curl!)
+          expect(provisioner).to receive(:create_destination!)
+          expect(provisioner).to receive(:install_babushka!)
+          expect(ui).to receive(:info).with("\n\n\n")
+          subject.prepare
+        end
+      end
+    end
+
+    context "with Babushka already installed" do
+      it "should not do anything" do
+        expect(provisioner).to receive(:in_path?).with("babushka").and_return(true)
+        expect(provisioner).to_not receive(:install_babushka!)
+        subject.prepare
+      end
+    end
+  end
+
+  describe "#do_babushka_run" do
+    let(:deps) { Array.new }
+    let(:config) { double "config", :deps => deps }
+
+    context "with no deps specified" do
+      it "should log a warning" do
+        expect(ui).to receive(:warn).with(<<-END.gsub(/ {10}|\n\Z/, ""), :scope => "the name")
+          Didn't find any Babushka deps to be met on the VM.
+          Add some to your Vagrantfile: babushka.meet 'my dep'
+        END
+        subject.do_babushka_run
+      end
+    end
+
+    context "with deps specified" do
+      let(:deps) { [dep1, dep2] }
+      let(:dep1) { double "dep 1", :id => "the dep 1" }
+      let(:dep2) { double "dep 2", :id => "the dep 2" }
+
+      it "should meet the deps" do
+        expect(ui).to receive(:info).with("Provisioning VM using Babushka...", :scope => "the name")
+        expect(ui).to receive(:info).with("Meeting Babushka dep 'the dep 1'", :scope => "the name")
+        expect(ui).to receive(:info).with("Executing 'foo'...", :scope => "the name")
+        expect(ui).to receive(:info).with("Meeting Babushka dep 'the dep 2'", :scope => "the name")
+        expect(ui).to receive(:info).with("Executing 'bar'...", :scope => "the name")
+        expect(provisioner).to receive(:command_for).with(dep1).twice().and_return("foo")
+        expect(communicate).to receive(:execute).with("foo")
+        expect(provisioner).to receive(:command_for).with(dep2).twice().and_return("bar")
+        expect(communicate).to receive(:execute).with("bar")
+        subject.do_babushka_run
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-babushka
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - Vladimir Valgis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-10 00:00:00.000000000 Z
+date: 2013-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,6 +90,7 @@ files:
 - spec/spec_helper.rb
 - spec/unit/vagrant-babushka/config_spec.rb
 - spec/unit/vagrant-babushka/dep_spec.rb
+- spec/unit/vagrant-babushka/provisioner_spec.rb
 - vagrant-babushka.gemspec
 homepage: https://github.com/vvalgis/vagrant-babushka
 licenses:
@@ -119,3 +120,4 @@ test_files:
 - spec/spec_helper.rb
 - spec/unit/vagrant-babushka/config_spec.rb
 - spec/unit/vagrant-babushka/dep_spec.rb
+- spec/unit/vagrant-babushka/provisioner_spec.rb