vagrant-hypconfigmgmt 0.0.1 → 0.0.2

data/lib/vagrant-hypconfigmgmt/version.rb

@@ -3,6 +3,6 @@
 
 module Vagrant
   module Hypconfigmgmt 
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+SimpleCov.start do
+  add_group "Command", "lib/vagrant-hypconfigmgmt/command.rb"
+end
+
+
+def get_random_string()
+  # random a-z0-9 string
+  # http://stackoverflow.com/a/3572953
+  length = 10
+  return rand(36 ** length).to_s(36)
+end

data/spec/unit/command/call_spec.rb

@@ -0,0 +1,93 @@
+# -*- encoding: utf-8 -*-
+# vim: set fileencoding=utf-8
+
+require 'spec_helper'
+require "vagrant-hypconfigmgmt/command"
+
+describe VagrantHypconfigmgmt::Command do
+  # create a fake app and env to pass into the VagrantHypconfigmgmt::Command constructor
+  let(:app) { lambda { |env| } }
+  let(:env) { { :machine => machine,  :ui => ui } }
+
+  # pretend env contains the Vagrant ui element
+  let(:ui) do
+    double('ui').tap do |ui|
+      allow(ui).to receive(:info) { nil }
+    end
+  end
+
+  # pretend env[:machine].config.hypconfigmgmt.enabled is false
+  let(:machine) do
+    double('machine').tap do |machine|
+      allow(machine).to receive(:config) { config }
+    end
+  end
+  let(:config) do
+    double('config').tap do |config|
+      allow(config).to receive(:hypconfigmgmt) { hypconfigmgmt }
+    end
+  end
+  let(:hypconfigmgmt) do
+    double('hypconfigmgmt').tap do |config|
+      allow(config).to receive(:enabled) { enabled }
+    end
+  end
+  let(:enabled) { false }
+
+
+  # Call the method under test after every 'it'. Similar to setUp in Python TestCase
+  after do
+    subject.call(env)
+  end
+
+  # instantiate class of which a method is to be tested
+  subject { described_class.new(app, env) }
+
+  # the method that we are going to test
+  describe "#call" do
+
+    context "when config hypconfigmgmt disabled (default)" do
+      it "does nothing but call the super" do
+        # check ensure_settings_configured is not called when plugin is disabled
+        expect(subject).to receive(:ensure_settings_configured).never
+        # check ensure_required_plugins_are_installed is not called when plugin is disabled
+        expect(subject).to receive(:ensure_required_plugins_are_installed).never
+        # check super is still called when plugin is disabled
+        expect(app).to receive(:call).with(env)
+      end
+    end
+
+    context "when config hypconfigmgmt enabled and no settings changed" do
+      # pretend env[:machine].config.hypconfigmgmt.enabled is true
+      let(:enabled) { true }
+
+      it "ensures settings configured" do
+        # check ensure_settings_configured is called when plugin is enabled
+        expect(subject).to receive(:ensure_settings_configured).with(env).and_return(false)  # no changed settings
+        # check ensure_required_plugins_are_installed is called when plugin is enabled
+        expect(subject).to receive(:ensure_required_plugins_are_installed).with(env).and_return(nil)
+	# check if we do not print the "please run vagrant up again" notice
+        expect(ui).to receive(:info).never.with("Your hypernode-vagrant is now configured. Please run \"vagrant up\" again.")
+        # check super is also called when plugin is enabled
+        expect(app).to receive(:call).with(env)
+      end
+    end
+
+    context "when config hypconfigmgmt enabled and settings changed" do
+      # pretend env[:machine].config.hypconfigmgmt.enabled is true
+      let(:enabled) { true }
+
+      it "ensures settings configured" do
+        # check ensure_settings_configured is called when plugin is enabled
+        expect(subject).to receive(:ensure_settings_configured).with(env).and_return(true)  # changed settings
+        # check ensure_required_plugins_are_installed is called when plugin is enabled
+        expect(subject).to receive(:ensure_required_plugins_are_installed).with(env).and_return(nil)
+	# check if we print the "please run vagrant up again" notice
+        expect(ui).to receive(:info).once.with("Your hypernode-vagrant is now configured. Please run \"vagrant up\" again.")
+        # interrupt the super call to make the user run 'vagrant up' again so changed settings take effect
+        expect(app).to receive(:call).never
+      end
+    end
+  end
+end
+

data/spec/unit/command/configure_magento_spec.rb

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+# vim: set fileencoding=utf-8
+
+require 'spec_helper'
+require "vagrant-hypconfigmgmt/command"
+
+describe VagrantHypconfigmgmt::Command do
+  # create a fake app and env to pass into the VagrantHypconfigmgmt::Command constructor
+  let(:app) { }
+  let(:env) { }
+
+  # Call the method under test after every 'it'. Similar to setUp in Python TestCase
+  after do
+    subject.configure_magento(env)
+  end
+
+  # instantiate class of which a method is to be tested
+  subject { described_class.new(app, env) }
+
+  # the method that we are going to test
+  describe "#configure_magento" do
+
+    context "when env is passed" do
+      it "configures the settings for magento" do
+	# check the magento settings is ensured to exist in the configuration file
+        expect(subject).to receive(:ensure_setting_exists).with('magento')
+	# check the magento version is ensured to be configured
+	expect(subject).to receive(:ensure_attribute_configured).with(
+          env, 'magento', 'version', AVAILABLE_MAGENTO_VERSIONS
+	)
+      end
+    end
+  end
+end
+

data/spec/unit/command/configure_php_spec.rb

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+# vim: set fileencoding=utf-8
+
+require 'spec_helper'
+require "vagrant-hypconfigmgmt/command"
+
+describe VagrantHypconfigmgmt::Command do
+  # create a fake app and env to pass into the VagrantHypconfigmgmt::Command constructor
+  let(:app) { }
+  let(:env) { }
+
+  # Call the method under test after every 'it'. Similar to setUp in Python TestCase
+  after do
+    subject.configure_php(env)
+  end
+
+  # instantiate class of which a method is to be tested
+  subject { described_class.new(app, env) }
+
+  # the method that we are going to test
+  describe "#configure_php" do
+
+    context "when env is passed" do
+      it "configures the settings for php" do
+	# check the php settings is ensured to exist in the configuration file
+        expect(subject).to receive(:ensure_setting_exists).with('php')
+	# check the php version is ensured to be configured
+	expect(subject).to receive(:ensure_attribute_configured).with(
+          env, 'php', 'version', AVAILABLE_PHP_VERSIONS
+	)
+      end
+    end
+  end
+end
+

data/spec/unit/command/configure_synced_folders_spec.rb

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+# vim: set fileencoding=utf-8
+
+require 'spec_helper'
+require "vagrant-hypconfigmgmt/command"
+
+describe VagrantHypconfigmgmt::Command do
+  # create a fake app and env to pass into the VagrantHypconfigmgmt::Command constructor
+  let(:app) { }
+  let(:env) { }
+
+  # Call the method under test after every 'it'. Similar to setUp in Python TestCase
+  after do
+    subject.configure_synced_folders(env)
+  end
+
+  # instantiate class of which a method is to be tested
+  subject { described_class.new(app, env) }
+
+  # the method that we are going to test
+  describe "#configure_synced_folders" do
+
+    context "when env is passed" do
+      it "configures all the settings for the synced folders" do
+        # check the magento mounts are configured
+        expect(subject).to receive(:ensure_magento_mounts_configured).with(env)
+        # check the directory to be mounted is validated against the magento version (pub symlink vs public)
+        expect(subject).to receive(:validate_magento2_root).with(env)
+        # check a message will be printed if gatling is not installed while the rsync fs type is specified
+        expect(subject).to receive(:inform_if_gatling_not_installed).with(env)
+      end
+    end
+  end
+end
+

data/spec/unit/command/configure_vagrant_spec.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+# vim: set fileencoding=utf-8
+
+require 'spec_helper'
+require "vagrant-hypconfigmgmt/command"
+
+describe VagrantHypconfigmgmt::Command do
+  # create a fake app and env to pass into the VagrantHypconfigmgmt::Command constructor
+  let(:app) { }
+  let(:env) { }
+
+  # Call the method under test after every 'it'. Similar to setUp in Python TestCase
+  after do
+    subject.configure_vagrant(env)
+  end
+
+  # instantiate class of which a method is to be tested
+  subject { described_class.new(app, env) }
+
+  # the method that we are going to test
+  describe "#configure_vagrant" do
+
+    context "when env is passed" do
+      it "configures the settings for vagrant" do
+	# check the vagrant settings is ensured to exist in the configuration file
+        expect(subject).to receive(:ensure_setting_exists).with('vagrant')
+	# check the vagrant box type is set to the right box for the pPHP version
+	expect(subject).to receive(:ensure_vagrant_box_type_configured).with(env)
+      end
+    end
+  end
+end
+

data/spec/unit/command/configure_varnish_spec.rb

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+# vim: set fileencoding=utf-8
+
+require 'spec_helper'
+require "vagrant-hypconfigmgmt/command"
+
+describe VagrantHypconfigmgmt::Command do
+  # create a fake app and env to pass into the VagrantHypconfigmgmt::Command constructor
+  let(:app) { }
+  let(:env) { }
+
+  # Call the method under test after every 'it'. Similar to setUp in Python TestCase
+  after do
+    subject.configure_varnish(env)
+  end
+
+  # instantiate class of which a method is to be tested
+  subject { described_class.new(app, env) }
+
+  # the method that we are going to test
+  describe "#configure_varnish" do
+
+    context "when env is passed" do
+      it "configures the settings for varnish" do
+	# check the varnish settings is ensured to exist in the configuration file
+        expect(subject).to receive(:ensure_setting_exists).with('varnish')
+	# check the varnish state is ensured to be configured
+	expect(subject).to receive(:ensure_attribute_configured).with(
+          env, 'varnish', 'state', AVAILABLE_VARNISH_STATES
+	)
+      end
+    end
+  end
+end
+

data/spec/unit/command/ensure_attribute_configured_spec.rb

@@ -0,0 +1,100 @@
+# -*- encoding: utf-8 -*-
+# vim: set fileencoding=utf-8
+
+require 'spec_helper'
+require "vagrant-hypconfigmgmt/command"
+
+
+describe VagrantHypconfigmgmt::Command do
+  # create a fake app and env to pass into the VagrantHypconfigmgmt::Command constructor
+  let(:app) { }
+  let(:env) { { :ui => ui } }
+  let(:setting_name) { get_random_string() }
+  let(:attribute_name) { get_random_string() }
+  let(:available) { [ ] }
+
+  # pretend env contains the Vagrant ui element
+  let(:ui) do
+    double('ui').tap do |ui|
+      allow(ui).to receive(:error) { nil }
+    end
+  end
+
+  # instantiate class of which a method is to be tested
+  subject { described_class.new(app, env) }
+
+  # the method that we are going to test
+  describe "#ensure_attribute_configured" do
+
+    context "when the attribute is defined for and is valid" do
+      let(:retrieved_settings) { { setting_name => { attribute_name => 'value2'} } } 
+      it "does not print an error and does not update the setting" do
+	# pretend we retrieve the settings and they contain a valid value
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if an error message is not printed
+        expect(ui).to receive(:error).never
+	# check if the settings are not changed because they are already correct
+        expect(subject).to receive(:update_settings).once.with(retrieved_settings)
+       
+        # call the method with a code block (anonymous function) that is not executed because there
+        # is already a correct value in the config: 'value2'
+        subject.ensure_attribute_configured(
+          env, setting_name, attribute_name, ['value1', 'value2']
+        ) { | env | 'value1' }
+      end
+    end
+
+    context "when the attribute is defined for the name but not in allowed value list" do
+      let(:retrieved_settings) { { setting_name => { attribute_name => 'invalid_value'} } } 
+      let(:expected_settings) { { setting_name => { attribute_name => 'value1' } } } 
+      it "prints an error about the invalid value, defines the attribute and writes it back to disk" do
+	# pretend we retrieve the settings and they contain an invalid value
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if an error message is printed
+        expect(ui).to receive(:error).once.with(/.*#{setting_name}.*#{attribute_name}.*/)
+	# check if the settings are updated with the yielded value passed as a block into the function
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+       
+        subject.ensure_attribute_configured(
+          env, setting_name, attribute_name, ['value1', 'value2']
+        ) { | env | 'value1' }
+      end
+    end
+
+    context "when the attribute is defined for the name but the allowed list has the value as an int" do
+      let(:retrieved_settings) { { setting_name => { attribute_name => '1'} } } 
+      it "does not update the setting because it is already valid" do
+	# pretend we retrieve the settings and they contain a string value
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if no error message is printed
+        expect(ui).to receive(:error).never
+	# check if the settings are not updated
+        expect(subject).to receive(:update_settings).once.with(retrieved_settings)
+       
+        subject.ensure_attribute_configured(
+          env, setting_name, attribute_name, [1, 2]
+        ) { | env | 2 }
+      end
+    end
+
+    context "when the attribute is not defined for the name" do
+      let(:retrieved_settings) { { setting_name => { } } } 
+      let(:expected_settings) { { setting_name => { attribute_name => 'value1' } } } 
+      it "defines the attribute and writes it back to disk" do
+	# pretend we retrieve the settings and they do not contain the attribute already
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if no error message is printed
+        expect(ui).to receive(:error).never
+	# check if the settings are updated with the yielded value passed as a block into the function
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+       
+        # a code block like "{ 'value1' }" is an anonymous function without a paramters 
+        # like: "{ | | 'value1' }", (or "lambda: 'value1'" in python)
+        subject.ensure_attribute_configured(
+          env, setting_name, attribute_name, ['value1', 'value2']
+        ) { 'value1' }
+      end
+    end
+  end
+end
+

data/spec/unit/command/ensure_magento_mounts_configured_spec.rb

@@ -0,0 +1,268 @@
+# -*- encoding: utf-8 -*-
+# vim: set fileencoding=utf-8
+
+require 'spec_helper'
+require "vagrant-hypconfigmgmt/command"
+
+
+describe VagrantHypconfigmgmt::Command do
+  # create a fake app and env to pass into the VagrantHypconfigmgmt::Command constructor
+  let(:app) { }
+  let(:env) { { :ui => ui } }
+  let(:setting_name) { get_random_string() }
+
+  # pretend env contains the Vagrant ui element
+  let(:ui) do
+    double('ui').tap do |ui|
+      allow(ui).to receive(:info) { nil }
+    end
+  end
+
+  # Call the method under test after every 'it'. Similar to setUp in Python TestCase
+  after do
+    subject.ensure_magento_mounts_configured(env)
+  end
+
+  # instantiate class of which a method is to be tested
+  subject { described_class.new(app, env) }
+
+  # the method that we are going to test
+  describe "#ensure_magento_mounts_configured" do
+
+    context "when magento version is 1 and there is a magento 2 mount" do
+      let(:retrieved_settings) { { 
+        "magento" => { "version" => 1 },
+        "fs" => { 
+          "folders" => {
+            "magento2" => { "host" => "data/web/magento2", "guest" => "/data/web/magento2" }
+	  }
+	}
+      } }
+      let(:expected_settings) { { 
+        "magento" => { "version" => 1 },
+        "fs" => { 
+          "folders" => { },
+          "disabled_folders" => {
+            "magento2" => { "host" => "data/web/magento2", "guest" => "/data/web/magento2" }
+	  }
+	}
+      } }
+      it "disables the magento 2 mount" do
+	# pretend we retrieve the settings and they specify magent->version 1 and a magento 2 mount
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we notify the user that the magento 2 mount is disabled
+        expect(ui).to receive(:info).once.with(/Disabling fs->folders->magento2.*/)
+	# check if the magento 2 mount is disabled
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+      end
+    end
+
+    context "when magento version is 2 and there is a magento 1 mount" do
+      let(:retrieved_settings) { { 
+        "magento" => { "version" => 2 },
+        "fs" => { 
+          "folders" => {
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  }
+	}
+      } }
+      let(:expected_settings) { { 
+        "magento" => { "version" => 2 },
+        "fs" => { 
+          "folders" => { },
+          "disabled_folders" => {
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  }
+	}
+      } }
+      it "disables the magento 1 mount" do
+	# pretend we retrieve the settings and they specify magent->version 2 and a magento 1 mount
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we notify the user that the magento 1 mount is disabled
+        expect(ui).to receive(:info).once.with(/Disabling fs->folders->magento1.*/)
+	# check if the magento 1 mount is disabled
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+      end
+    end
+
+    context "when magento version is 1 and there are mounts for both magento 1 and 2" do
+      let(:retrieved_settings) { { 
+        "magento" => { "version" => 1 },
+        "fs" => { 
+          "folders" => {
+            "magento2" => { "host" => "data/web/magento2", "guest" => "/data/web/magento2" },
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  }
+	}
+      } }
+      let(:expected_settings) { { 
+        "magento" => { "version" => 1 },
+        "fs" => { 
+          "folders" => { 
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  },
+          "disabled_folders" => {
+            "magento2" => { "host" => "data/web/magento2", "guest" => "/data/web/magento2" }
+	  }
+	}
+      } }
+      it "disables the magento 2 mount but keeps the magento 1 mount enabled" do
+	# pretend we retrieve the settings and they specify magent->version 1 and mounts for both magento 1 and 2
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we notify the user that the magento 2 mount is disabled
+        expect(ui).to receive(:info).once.with(/Disabling fs->folders->magento2.*/)
+	# check if the magento 2 mount is disabled but the magento 1 mount is still enabled
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+      end
+    end
+
+    context "when magento version is 2 and there are mounts for both magento 1 and 2" do
+      let(:retrieved_settings) { { 
+        "magento" => { "version" => 2 },
+        "fs" => { 
+          "folders" => {
+            "magento2" => { "host" => "data/web/magento2", "guest" => "/data/web/magento2" },
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  }
+	}
+      } }
+      let(:expected_settings) { { 
+        "magento" => { "version" => 2 },
+        "fs" => { 
+          "folders" => { 
+            "magento2" => { "host" => "data/web/magento2", "guest" => "/data/web/magento2" }
+	  },
+          "disabled_folders" => {
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  }
+	}
+      } }
+      it "disables the magento 1 mount but keeps the magento 2 mount enabled" do
+	# pretend we retrieve the settings and they specify magent->version 2 and mounts for both magento 1 and 2
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we notify the user that the magento 1 mount is disabled
+        expect(ui).to receive(:info).once.with(/Disabling fs->folders->magento1.*/)
+	# check if the magento 1 mount is disabled but the magento 2 mount is still enabled
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+      end
+    end
+
+    context "when magento version is whatever and there are no magento1 or magento2 mounts" do
+      let(:retrieved_settings) { { 
+        "magento" => { "version" => 1234 },
+        "fs" => {
+            "nginx" => { "host" => "data/web/nginx", "guest" => "/data/web/nginx" }
+	 }
+      } }
+      it "does not change the settings" do
+	# pretend we retrieve the settings and they specify a random magent->version and no mounts we should automatically enable/disable
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we don't notify the user
+        expect(ui).to receive(:info).never.with(/Disabling.*/)
+        expect(ui).to receive(:info).never.with(/Re-enabling.*/)
+	# check if no settings were changed
+        expect(subject).to receive(:update_settings).once.with(retrieved_settings)
+      end
+    end
+
+    context "when magento version is 2 and there is a disabled magento 2 mount" do
+      let(:retrieved_settings) { { 
+        "magento" => { "version" => 2 },
+        "fs" => { 
+          "folders" => {
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  },
+          "disabled_folders" => {
+            "magento2" => { "host" => "data/web/magento2", "guest" => "/data/web/magento2" },
+	  }
+	}
+      } }
+      let(:expected_settings) { { 
+        "magento" => { "version" => 2 },
+        "fs" => { 
+          "folders" => {
+            "magento2" => { "host" => "data/web/magento2", "guest" => "/data/web/magento2" },
+	  },
+          "disabled_folders" => {
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  }
+	}
+      } }
+      it "disables the magento 1 mount and re-enabled the magento 2 mount" do
+	# pretend we retrieve the settings and they specify magent->version 2 and mounts for both magento 1 and 2
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we notify the user that the magento 1 mount is disabled
+        expect(ui).to receive(:info).once.with(/Disabling fs->folders->magento1.*/)
+	# check if we notify the user that the magento 2 mount is re-enabled
+        expect(ui).to receive(:info).once.with(/Re-enabling fs->disabled_folders->magento2.*/)
+	# check if the magento 1 mount is disabled and the magento 2 mount is re-enabled
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+      end
+    end
+
+    context "when magento version is 1 and there is a disabled magento 1 mount" do
+      let(:retrieved_settings) { { 
+        "magento" => { "version" => 1 },
+        "fs" => { 
+          "folders" => {
+            "magento2" => { "host" => "data/web/magento2", "guest" => "/data/web/magento2" },
+	  },
+          "disabled_folders" => {
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  }
+	}
+      } }
+      let(:expected_settings) { { 
+        "magento" => { "version" => 1 },
+        "fs" => { 
+          "folders" => {
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  },
+          "disabled_folders" => {
+            "magento2" => { "host" => "data/web/magento2", "guest" => "/data/web/magento2" },
+	  }
+	}
+      } }
+      it "disables the magento 2 mount and re-enabled the magento 1 mount" do
+	# pretend we retrieve the settings and they specify magent->version 1 and mounts for both magento 1 and 2
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we notify the user that the magento 2 mount is disabled
+        expect(ui).to receive(:info).once.with(/Disabling fs->folders->magento2.*/)
+	# check if we notify the user that the magento 1 mount is re-enabled
+        expect(ui).to receive(:info).once.with(/Re-enabling fs->disabled_folders->magento1.*/)
+	# check if the magento 2 mount is disabled and the magento 1 mount is re-enabled
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+      end
+    end
+
+    context "when no disabled folders settings has to be kept" do
+      let(:retrieved_settings) { { 
+        "magento" => { "version" => 1 },
+        "fs" => { 
+          "folders" => { },
+          "disabled_folders" => {
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  }
+	}
+      } }
+      let(:expected_settings) { { 
+        "magento" => { "version" => 1 },
+        "fs" => { 
+          "folders" => {
+            "magento1" => { "host" => "data/web/public", "guest" => "/data/web/public" }
+	  }
+	}
+      } }
+      it "re-enables the magento 1 mount and removes the empty disabled_folders hash" do
+	# pretend we retrieve the settings and they specify magent->version 1 and mounts for magento 1
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we notify the user that the magento 1 mount is re-enabled
+        expect(ui).to receive(:info).once.with(/Re-enabling fs->disabled_folders->magento1.*/)
+	# check if the disabled_folders hash is deleted and the magento 1 mount is re-enabled
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+      end
+    end
+
+  end
+end
+