vagrant-mirror 0.1.0.alpha

data/spec/vagrant-mirror/config_spec.rb

@@ -0,0 +1,161 @@
+describe Vagrant::Mirror::Config do
+
+  context "with no configuration" do
+
+    it "returns an empty array of mirrored folders" do
+      subject.folders.should eq([])
+    end
+
+  end
+
+  context "when a mirrored folder is added with no options" do
+
+    before(:each) do
+      subject.folder "foo", "/var/path"
+    end
+
+    it "adds it to the list of folders" do
+      subject.folders.count.should eq 1
+      subject.folders[0][:name].should eq 'foo'
+      subject.folders[0][:guest_path].should eq "/var/path"
+    end
+
+    it "does not beep by default" do
+      subject.folders[0][:beep].should be_false
+    end
+
+    it "does not delete by default" do
+      subject.folders[0][:delete].should be_false
+    end
+
+    it "does not exclude anything by default" do
+      subject.folders[0][:exclude].should eq([])
+    end
+
+    it "does not make any symlinks by default" do
+      subject.folders[0][:symlinks].should eq([])
+    end
+
+  end
+
+  it "provides a shortcut for mirroring the vagrant root to the guest" do
+    subject.vagrant_root "/var/vagrant"
+
+    subject.folders.count.should eq 1
+    subject.folders[0][:name].should eq 'v-root'
+    subject.folders[0][:guest_path].should eq "/var/vagrant"
+  end
+
+  it "can accept a folder with the delete option set" do
+    subject.vagrant_root "/var/vagrant", { :delete => true }
+
+    subject.folders[0][:delete].should be_true
+  end
+
+  it "can accept a folder with the beep option set" do
+    subject.vagrant_root "/var/vagrant", { :beep => true }
+
+    subject.folders[0][:beep].should be_true
+  end
+
+  it "can accept a folder with exclude patterns set" do
+    subject.vagrant_root "/var/vagrant", { :exclude => ['/docs'] }
+
+    subject.folders[0][:exclude].should eq(['/docs'])
+  end
+
+  context "when adding a folder with excludes and symlinks" do
+    before (:each) do
+      subject.vagrant_root "/var/vagrant", { :exclude => ['/docs'], :symlinks => ['/log'] }
+    end
+
+    it "stores the list of symlinks" do
+      subject.folders[0][:symlinks].should eq(['/log'])
+    end
+
+    it "adds the symlink to the rsync exclude list" do
+      subject.folders[0][:exclude].should eq(['/docs', '/log'])
+    end
+
+  end
+
+  context "when adding multiple folders" do
+    before (:each) do
+      subject.vagrant_root "/var/vagrant", { :exclude => ['/docs'], :symlinks => ['/log'] }
+      subject.folder "foo", "/var/foo", { :exclude => ['/docs2'], :symlinks => ['/log2'] }
+    end
+
+    it "builds a list of folders" do
+      subject.folders.count.should eq(2)
+      subject.folders[0][:name].should eq('v-root')
+      subject.folders[1][:name].should eq('foo')
+    end
+  end
+
+  context "when validating configuration" do
+
+    before :each do
+      @env = Vagrant::Environment.new
+      @errors = Vagrant::Config::ErrorRecorder.new
+    end
+
+    it "rejects folders with an empty shared folder name" do
+      subject.folder "", "/var/path"
+      subject.validate(@env, @errors)
+
+      @errors.errors.empty?.should be_false
+    end
+
+    it "rejects folders with an empty guest path" do
+      subject.folder "foo", ""
+      subject.validate(@env, @errors)
+
+      @errors.errors.empty?.should be_false
+    end
+
+    it "rejects folders which are not already a vagrant shared folder" do
+      pending
+    end
+
+    it "rejects folders with nil paths" do
+      subject.folder nil, nil
+      subject.validate(@env, @errors)
+      @errors.errors.count.should eq 2
+    end
+
+    it "rejects unknown options" do
+      subject.vagrant_root "/guest/path", { :foo => :bar }
+      subject.validate(@env, @errors)
+
+      @errors.errors.empty?.should be_false
+    end
+
+    it "validates with valid options" do
+      subject.vagrant_root "/var/guest", { :symlinks => [ 'logs'], :exclude => ['exclude'], :delete => true, :beep => true }
+      subject.validate(@env, @errors)
+
+      @errors.errors.empty?.should be_true
+    end
+
+  end
+
+  context "when merging configuration" do
+
+    it "combines the folders from each configuration source" do
+      subject.folder "low", "/low-level"
+      next_config = Vagrant::Mirror::Config.new
+      next_config.folder "top", "/top-level"
+      merged = subject.merge(next_config)
+
+      merged.should be_a Vagrant::Mirror::Config
+      merged.folders.should have(2).items
+
+      expected_result = [
+        subject.folders[0],
+        next_config.folders[0]
+      ]
+
+      merged.folders.should eq expected_result
+    end
+  end
+end

data/spec/vagrant-mirror/listener/host_spec.rb

@@ -0,0 +1,96 @@
+describe Vagrant::Mirror::Listener::Host do
+
+  let (:queue) { double("Queue").as_null_object }
+
+  subject { Vagrant::Mirror::Listener::Host.new('c:/host', queue) }
+
+  before (:each) do
+    Listen.stub(:to).as_null_object
+  end
+
+  describe "#listen!" do
+    it "listens to the host directory" do
+      Listen.should_receive(:to).with('c:/host', anything())
+
+      subject.listen!
+    end
+
+    it "requests relative paths" do
+      Listen.should_receive(:to)
+        .with(anything(), hash_including( :relative_paths => true ))
+
+      subject.listen!
+    end
+
+    context "when changes received" do
+      before(:each) do
+        Listen.stub(:to)
+          .and_yield(['modified'],[],[])
+          .and_yield([],['added'],[])
+          .and_yield([],[],['removed'])
+          .and_yield(['modified1'],['added1'],['removed1'])
+      end
+
+      it "pushes added files onto the queue" do
+        queue.should_receive(:"<<")
+          .with(hash_including(:added => ['added']))
+
+        subject.listen!
+      end
+
+      it "pushes modified files onto the queue" do
+        queue.should_receive(:"<<")
+          .with(hash_including(:modified => ['modified']))
+
+        subject.listen!
+      end
+
+      it "pushes removed files onto the queue" do
+        queue.should_receive(:"<<")
+          .with(hash_including(:removed => ['removed']))
+
+        subject.listen!
+      end
+
+      it "handles simultaneous changes" do
+        queue.should_receive(:"<<")
+          .with(hash_including({
+            :added => ['added1'],
+            :modified => ['modified1'],
+            :removed => ['removed1']
+            }))
+
+        subject.listen!
+      end
+
+    end
+
+    context "with a close signal" do
+      it "stops listening"
+    end
+  end
+
+  describe "#listen" do
+    let (:thread) { double("Thread") }
+
+    before (:each) do
+      Thread.stub(:new).and_yield.and_return(thread)
+    end
+
+    it "starts a new thread" do
+      Thread.should_receive(:new)
+
+      subject.listen
+    end
+
+    it "runs listen! in the new thread" do
+      Listen.should_receive(:to)
+
+      subject.listen
+    end
+
+    it "returns the thread" do
+      subject.listen.should eq thread
+    end
+  end
+end

data/spec/vagrant-mirror/middleware/mirror_spec.rb

@@ -0,0 +1,188 @@
+describe Vagrant::Mirror::Middleware::Mirror do
+  # Shared mocks
+  let (:env)           { Vagrant::Action::Environment.new }
+  let (:vm)            { double("Vagrant::VM").as_null_object }
+  let (:ui)            { double("Vagrant::UI::Interface").as_null_object }
+  let (:app)           { double("Object").as_null_object }
+  let (:channel)       { double("Vagrant::Communication::SSH").as_null_object }
+  let (:config)        { double("Object").as_null_object }
+  let (:configmirror)  { Vagrant::Mirror::Config.new }
+  let (:configvm)      { Vagrant::Config::VMConfig.new }
+  let (:queue)         { double("Queue").as_null_object }
+  let (:guard)         { double("Vagrant::Mirror::Listener::Host").as_null_object }
+  let (:rsync)         { double("Vagrant::Mirror::Rsync").as_null_object }
+
+  # Set basic stubs for shared mocks
+  before (:each) do
+    env[:vm] = vm
+    env[:ui] = ui
+    env[:root_path] = Dir.pwd
+
+    vm.stub(:config).and_return config
+    config.stub(:mirror).and_return configmirror
+    config.stub(:vm).and_return configvm
+
+    vm.stub(:channel).and_return channel
+
+    Vagrant::Mirror::Rsync.stub(:new).and_return rsync
+
+    app.stub(:call)
+
+    Vagrant::Mirror::Listener::Host.stub(:new).and_return(guard)
+    Queue.stub(:new).and_return(queue)
+    queue.stub(:pop).and_return({ :quit => true})
+  end
+
+  subject { Vagrant::Mirror::Middleware::Mirror.new(app, env) }
+
+  describe "#call" do
+    shared_examples "chained mirror middleware" do
+      it "calls the next middleware" do
+        app.should_receive(:call).with(env)
+
+        subject.call(env)
+      end
+    end
+
+    context "with no mirrored folders" do
+      before (:each) do
+        configmirror.stub(:folders).and_return([])
+      end
+
+      it_behaves_like "chained mirror middleware"
+    end
+
+    context "with a mirrored folder" do
+
+      before (:each) do
+        config.mirror.vagrant_root '/var/guest'
+        config.vm.share_folder("v-root", "/vagrant", ".")
+      end
+
+      it "logs the start of mirroring" do
+        ui.should_receive(:info).with("Beginning directory mirroring")
+
+        subject.call(env)
+      end
+
+      it "creates a Guard listener on the host path" do
+        Vagrant::Mirror::Listener::Host.should_receive(:new)
+          .with(env[:root_path], queue)
+
+        subject.call(env)
+      end
+
+      context "creates an rsync class for the folder pair" do
+        it "creates an rsync class for the folder pair" do
+          Vagrant::Mirror::Rsync.should_receive(:new)
+            .and_return(rsync)
+
+          subject.call(env)
+        end
+
+        it "passes the vm to rsync" do
+          Vagrant::Mirror::Rsync.should_receive(:new)
+            .with(vm, anything, anything, anything)
+            .and_return(rsync)
+
+          subject.call(env)
+        end
+
+        it "passes the guest shared folder path for the folder pair to rsync" do
+          Vagrant::Mirror::Rsync.should_receive(:new)
+            .with(anything, "/vagrant", anything, anything)
+            .and_return(rsync)
+
+          subject.call(env)
+        end
+
+        it "passes the host shared folder path for the folder pair to rsync" do
+          Vagrant::Mirror::Rsync.should_receive(:new)
+            .with(anything, anything, env[:root_path], anything)
+            .and_return(rsync)
+
+          subject.call(env)
+        end
+
+        it "passes the folder configuration to rsync" do
+          Vagrant::Mirror::Rsync.should_receive(:new)
+            .with(anything, anything, anything, config.mirror.folders[0])
+            .and_return(rsync)
+
+          subject.call(env)
+        end
+      end
+
+      it "listens for changes in the host path" do
+        guard.should_receive(:listen)
+
+        subject.call(env)
+      end
+
+      context "with notifications in the queue" do
+
+        let (:added)     { ['added'] }
+        let (:modified)  { ['modified','modified2'] }
+        let (:removed)   { ['removed'] }
+        let (:rm_exists) { true }
+
+        before (:each) do
+          queue.stub(:pop).and_return(
+            { :added => added, :modified => modified, :removed => removed },
+            { :added => added, :modified => modified, :removed => removed },
+            { :quit => true })
+          File.stub(:exists?).with("#{env[:root_path]}/removed").and_return(rm_exists)
+        end
+
+        it "runs rsync one by one for each added and modified file" do
+          rsync.should_receive(:run).with("added")
+          rsync.should_receive(:run).with("modified")
+          rsync.should_receive(:run).with("modified2")
+
+          subject.call(env)
+          sleep 0.2
+        end
+
+        # Sometimes Guard flags a file as deleted that still exists - during certain types of
+        # atomic file writes, we think. So we should delete the file remotely if so, or sync if not.
+        context "if deleted files have been deleted" do
+          let (:rm_exists) { false }
+
+          it "deletes them by SSH" do
+            channel.should_receive(:sudo).with('rm /var/guest/removed')
+
+            subject.call(env)
+            sleep 0.2
+          end
+        end
+
+        context "if deleted files have not been deleted" do
+          let (:rm_exists) { true }
+
+          it "runs rsync on the file" do
+            rsync.should_receive(:run).with('removed')
+
+            subject.call(env)
+            sleep 0.2
+          end
+        end
+
+      end
+
+      shared_examples "finishing mirroring" do
+        it "signals the Guard listener to quit"
+        it "waits for the Guard listener to quit"
+        it "processes remaining jobs in the queue"
+        it "calls the next middleware"
+      end
+
+      context "when signaled to quit" do
+        it_behaves_like "finishing mirroring"
+      end
+
+      context "when user presses q on the console" do
+        it_behaves_like "finishing mirroring"
+      end
+    end
+  end
+end

data/spec/vagrant-mirror/middleware/sync_spec.rb

@@ -0,0 +1,152 @@
+describe Vagrant::Mirror::Middleware::Sync do
+  # Shared mocks
+  let (:env)           { Vagrant::Action::Environment.new }
+  let (:vm)            { double("Vagrant::VM").as_null_object }
+  let (:channel)       { double("Vagrant::Communication::SSH").as_null_object }
+  let (:ui)            { double("Vagrant::UI::Interface").as_null_object }
+  let (:app)           { double("Object").as_null_object }
+  let (:config)        { double("Object").as_null_object }
+  let (:configmirror)  { Vagrant::Mirror::Config.new }
+  let (:configvm)      { Vagrant::Config::VMConfig.new }
+  let (:rsync)         { double("Vagrant::Mirror::Rsync").as_null_object }
+
+  # Set basic stubs for shared mocks
+  before (:each) do
+    env[:vm] = vm
+    env[:ui] = ui
+    env[:root_path] = Dir.pwd
+
+    vm.stub(:config).and_return config
+    config.stub(:mirror).and_return configmirror
+    config.stub(:vm).and_return configvm
+
+    vm.stub(:channel).and_return channel
+
+    Vagrant::Mirror::Rsync.stub(:new).and_return rsync
+
+    app.stub(:call)
+
+  end
+
+  subject { Vagrant::Mirror::Middleware::Sync.new(app, env) }
+
+  describe "#call" do
+
+    shared_examples "chained middleware" do
+      it "calls the next middleware" do
+        app.should_receive(:call).with(env)
+
+        subject.call(env)
+      end
+    end
+
+    context "with no mirrored folders" do
+      it_behaves_like "chained middleware"
+    end
+
+    context "with a mirrored folder" do
+      before (:each) do
+        config.mirror.vagrant_root '/var/guest'
+        config.vm.share_folder("v-root", "/vagrant", ".")
+      end
+
+      it_behaves_like "chained middleware"
+
+      it "creates an rsync class for the folder pair" do
+        Vagrant::Mirror::Rsync.should_receive(:new)
+          .and_return(rsync)
+
+        subject.call(env)
+      end
+
+      it "passes the vm to rsync" do
+        Vagrant::Mirror::Rsync.should_receive(:new)
+          .with(vm, anything, anything, anything)
+          .and_return(rsync)
+
+        subject.call(env)
+      end
+
+      it "passes the guest shared folder path for the folder pair to rsync" do
+        Vagrant::Mirror::Rsync.should_receive(:new)
+          .with(anything, "/vagrant", anything, anything)
+          .and_return(rsync)
+
+        subject.call(env)
+      end
+
+      it "passes the host shared folder path for the folder pair to rsync" do
+        Vagrant::Mirror::Rsync.should_receive(:new)
+          .with(anything, anything, env[:root_path], anything)
+          .and_return(rsync)
+
+        subject.call(env)
+      end
+
+      it "passes the folder configuration to rsync" do
+        Vagrant::Mirror::Rsync.should_receive(:new)
+          .with(anything, anything, anything, config.mirror.folders[0])
+          .and_return(rsync)
+
+        subject.call(env)
+      end
+
+      it "runs rsync for the root of the mirrored folder" do
+        rsync.should_receive(:run)
+          .with("/")
+
+        subject.call(env)
+      end
+    end
+
+    context "with two mirrored folders" do
+      before (:each) do
+        config.mirror.folder "foo", "/var/foo"
+        config.mirror.folder "bar", "/var/bar"
+      end
+
+      it "throws an exception as this is not yet supported" do
+        expect { subject.call(env) }.to raise_error(Vagrant::Mirror::Errors::MultipleFoldersNotSupported)
+      end
+    end
+
+    context "when the mirror config includes symlinks" do
+      let (:host_path) { File.join(Dir.pwd, 'logs') }
+
+      before (:each) do
+        config.mirror.vagrant_root "/var/vagrant", { :symlinks => ['logs'] }
+        config.vm.share_folder("v-root", "/vagrant", ".")
+
+        File.stub(:exists?).with(host_path).and_return true
+      end
+
+      context "if the host folder does not exist" do
+        let (:host_path) { File.join(Dir.pwd, 'logs') }
+
+        before (:each) do
+          File.stub(:exists?).with(host_path).and_return false
+        end
+
+        it "creates the folder on the host" do
+          FileUtils.stub(:mkdir_p).with(host_path)
+        end
+      end
+
+      it "creates a symlink on the guest" do
+        channel.should_receive(:sudo).with('rm -f /var/vagrant/logs && mkdir -p /var/vagrant && ln -s /vagrant/logs /var/vagrant/logs')
+
+        subject.call(env)
+      end
+    end
+
+    context "when the mirrored config includes invalid shared folders" do
+      before (:each) do
+        config.mirror.folder "unknown", "/var/whoops"
+      end
+
+      it "throws an exception" do
+        expect { subject.call(env) }.to raise_error(Vagrant::Mirror::Errors::SharedFolderNotMapped)
+      end
+    end
+  end
+end

data/spec/vagrant-mirror/rsync_spec.rb

@@ -0,0 +1,75 @@
+describe Vagrant::Mirror::Rsync do
+
+  # Shared mocks
+  let (:vm)            { double("Vagrant::VM").as_null_object }
+  let (:channel)       { double("Vagrant::Communication::SSH").as_null_object }
+  let (:guest_sf_path) { '/vagrant' }
+  let (:host_path)     { 'c:/vagrant' }
+  let (:cfg_delete)    { false }
+  let (:cfg_exclude)   { [] }
+  let (:cfg_guest)     { '/var/vagrant' }
+  let (:mirror_config) { { :name => 'v-root', :guest_path => '/var/vagrant', :delete => false,
+                           :exclude => [], :beep => false, :symlinks => [] } }
+
+  # Set basic stubs for shared mocks
+  before (:each) do
+    vm.stub(:channel).and_return channel
+
+    File.stub(:directory?).and_return(false)
+    File.stub(:directory?).with('c:/vagrant/dir').and_return(true)
+  end
+
+  subject { Vagrant::Mirror::Rsync.new(vm, guest_sf_path, host_path, mirror_config) }
+
+  describe "#run" do
+
+    shared_examples "running rsync to update the path" do | path, expect_source, expect_dest |
+      context "with no exclude paths" do
+        it "runs the expected rsync command" do
+          channel.should_receive(:sudo).with("rsync -av #{expect_source} #{expect_dest}")
+
+          subject.run(path)
+        end
+      end
+
+      context "with exclude paths" do
+        let (:mirror_config) { { :name => 'v-root', :guest_path => '/var/vagrant', :delete => false,
+                           :exclude => ['.git', 'cache'], :beep => false, :symlinks => [] } }
+
+        it "runs the expected rsync command"  do
+          channel.should_receive(:sudo).with("rsync -av --exclude '.git' --exclude 'cache' #{expect_source} #{expect_dest}")
+
+          subject.run(path)
+        end
+      end
+
+      context "with delete enabled" do
+        let (:mirror_config) { { :name => 'v-root', :guest_path => '/var/vagrant', :delete => true,
+                           :exclude => [], :beep => false, :symlinks => [] } }
+
+        it "runs the expected rsync command"  do
+          channel.should_receive(:sudo).with("rsync -av --del #{expect_source} #{expect_dest}")
+
+          subject.run(path)
+        end
+      end
+    end
+
+    context "when passed an empty path" do
+      it_behaves_like "running rsync to update the path", '', '/vagrant/', '/var/vagrant/'
+    end
+
+    context "when passed the root path" do
+      it_behaves_like "running rsync to update the path", '/', '/vagrant/', '/var/vagrant/'
+    end
+
+    context "when passed a file path" do
+      it_behaves_like "running rsync to update the path", 'file', '/vagrant/file', '/var/vagrant/file'
+    end
+
+    context "when passed a directory path" do
+      it_behaves_like "running rsync to update the path", 'dir', '/vagrant/dir/', '/var/vagrant/dir/'
+    end
+
+  end
+end

data/spec/vagrant-mirror_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Vagrant::Mirror do
+  it { should be_a(Module) }
+end