vagrant-hypconfigmgmt 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9cee22257d778227a2d1b2b2286e7ee518ee55c
-  data.tar.gz: 96bef3d160c2e5a77b5fa7e884c916906bd62abd
+  metadata.gz: b27e5b0ad9ed5e0a31db8176cb3c439a2206741e
+  data.tar.gz: 9642e941dae96c39f741a523fa9abf9a566861ef
 SHA512:
-  metadata.gz: f51b5e656562c661f5d1b8bc35e2a947f04675810f165bf1506e5675ef7cae288619825791179ea89b4d4e1cfe97fa2859f2298ced0e77f2d1e1575e2dd3d60a
-  data.tar.gz: 2d9b031d84ea2c15e4d4c372517aa59f6c578c35717d82b7075ad1d108bdbfdcb975333ef546f7be06a0f4ca9e3626131386cba4dd773ec58f712159659cdad0
+  metadata.gz: 9ca8d0dc091ebdf6ca7aeb256052a9ff78adc2f9768b493f7cdf1c465c44d8ba7e5bd3fe43c141516bdbfb051a9d1938a01f80c58f23e24af67f48cd762db428
+  data.tar.gz: 3210f4d40bdb425cb71adc56fdb897e2620b87d40972a58a43698981927dde64847e3426ad480b244e09a06bcbe646c405d75a9f43e23e1c1a71acac1d42b0e6

data/README.md

@@ -11,5 +11,5 @@ Create the gemfile (package)
 ```
 $ make
 rake build
-vagrant-hypconfigmgmt 0.0.2 built to pkg/vagrant-hypconfigmgmt-0.0.2.gem.
+vagrant-hypconfigmgmt 0.0.3 built to pkg/vagrant-hypconfigmgmt-0.0.3.gem.
 ```

data/lib/vagrant-hypconfigmgmt/command.rb

@@ -10,12 +10,24 @@ AVAILABLE_PHP_VERSIONS = [5.5, 7.0]
 DEFAULT_VARNISH_STATE = false
 AVAILABLE_VARNISH_STATES = [true, false]
 
+DEFAULT_FIREWALL_STATE = false
+AVAILABLE_FIREWALL_STATES = [true, false]
+
 # paths to local settings file
 H_V_SETTINGS_FILE = "local.yml"
 H_V_BASE_SETTINGS_FILE = ".local.base.yml"
 
 RECOMMENDED_PLUGINS = ["vagrant-hostmanager", "vagrant-vbguest"]
 
+# filesystem types that need to have the firewall disabled in the guest
+# because they otherwise can cause problems
+FIREWALL_INCOMPATIBLE_FS_TYPES = ['nfs_guest']
+
+AVAILABLE_FS_TYPES = ['nfs', 'nfs_guest', 'virtualbox', 'rsync']
+# This is the only one that works on all platforms.
+# Perhaps we should consider using a different default on different platforms.
+DEFAULT_FS_TYPE = 'virtualbox'
+
 
 module VagrantHypconfigmgmt
   class Command
@@ -112,8 +124,38 @@ module VagrantHypconfigmgmt
       env[:ui].info(message)
       return varnish_state
     end
+
+
+    def get_firewall_state(env)
+      ask_message = "Do you want to enable the production-like firewall? Enter true or false [default false]: "
+      firewall_enabled = get_setting(env, AVAILABLE_FIREWALL_STATES, DEFAULT_FIREWALL_STATE, ask_message)
+      firewall_state = firewall_enabled == 'true' ? true : false
+      message = "The firewall will be #{firewall_state ? 'enabled' : 'disabled'}"
+      env[:ui].info(message)
+      return firewall_state
+    end
     
 
+    def get_fs_type(env)
+      ask_message = "What filesystem type do you want to use? Options: nfs_guest, nfs, rsync, virtualbox [default #{DEFAULT_FS_TYPE}]: "
+      fs_type = get_setting(env, AVAILABLE_FS_TYPES, DEFAULT_FS_TYPE, ask_message)
+      case fs_type
+        when "nfs"
+          message = ("The guest will mount NFS folders served by the host.")
+        when "nfs_guest"
+          message = ("The host will mount NFS folders served by the guest")
+        when "virtualbox"
+          message = ("Virtualbox is the default fs type. If you later want to try a faster fs type like nfs_guest, edit local.yml")
+        when "rsync"
+          message = ("Will use rsync to sync the folders. Don't forget to start the filesync with 'vagrant rsync-auto' or 'vagrant gatling-rsync-auto'!")
+        else
+          message = ("Unknown filesystem type. If it's valid for Vagrant then there is no problem. Otherwise you can edit local.yml to change it.")
+      end 
+      env[:ui].info(message)
+      return fs_type
+    end
+
+
     # Make sure we don't link /data/web/public on Magento 2 Vagrants
     # because that dir will be a symlink to /data/web/magento2/pub and 
     # we mount that. On Magento 1 Vagrants we need to make sure we don't
@@ -210,8 +252,25 @@ HEREDOC
       end
       update_settings(settings)
     end
+
       
+    def ensure_firewall_disabled_for_incompatible_fs_types(env)
+      settings = retrieve_settings()
+      if FIREWALL_INCOMPATIBLE_FS_TYPES.include?(settings['fs']['type'])
+        env[:ui].info("Disabling the firewall in the guest because fs type #{settings['fs']['type']} might run into some problems otherwise.")
+        settings['firewall']['state'] = false
+      end
+      update_settings(settings)
+    end
+
     
+    def ensure_fs_type_configured(env)
+      settings = retrieve_settings()
+      settings['fs']['type'] ||= get_fs_type(env)
+      update_settings(settings)
+    end
+    
+
     def configure_magento(env)
       ensure_setting_exists('magento')
       ensure_attribute_configured(
@@ -237,9 +296,21 @@ HEREDOC
         AVAILABLE_VARNISH_STATES
       ) { get_varnish_state(env) }
     end
+
+
+    def configure_firewall(env)
+      ensure_setting_exists('firewall')
+      ensure_firewall_disabled_for_incompatible_fs_types(env)
+      ensure_attribute_configured(
+        env, 'firewall', 'state',
+        AVAILABLE_FIREWALL_STATES
+      ) { get_firewall_state(env) }
+    end
     
     
     def configure_synced_folders(env)
+      ensure_setting_exists('fs')
+      ensure_fs_type_configured(env)
       ensure_magento_mounts_configured(env)
       validate_magento2_root(env)
       inform_if_gatling_not_installed(env)
@@ -258,6 +329,7 @@ HEREDOC
       configure_php(env)
       configure_varnish(env)
       configure_synced_folders(env)
+      configure_firewall(env)
       configure_vagrant(env)
       new_settings = retrieve_settings()
       return new_settings.to_yaml != old_settings.to_yaml

data/lib/vagrant-hypconfigmgmt/version.rb

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

data/spec/unit/command/configure_firewall_spec.rb

@@ -0,0 +1,37 @@
+# -*- 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_firewall(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_firewall" do
+
+    context "when env is passed" do
+      it "configures the settings for firewall" do
+	# check the firewall settings is ensured to exist in the configuration file
+        expect(subject).to receive(:ensure_setting_exists).with('firewall')
+	# check the firewall is disabled for incompatible fs types
+	expect(subject).to receive(:ensure_firewall_disabled_for_incompatible_fs_types).with(env)
+	# check the firewall state is ensured to be configured
+	expect(subject).to receive(:ensure_attribute_configured).with(
+          env, 'firewall', 'state', AVAILABLE_FIREWALL_STATES
+	)
+      end
+    end
+  end
+end
+

data/spec/unit/command/configure_synced_folders_spec.rb

@@ -22,12 +22,16 @@ describe VagrantHypconfigmgmt::Command do
 
     context "when env is passed" do
       it "configures all the settings for the synced folders" do
+	# check if the fs settings is ensured to exist
+	expect(subject).to receive(:ensure_setting_exists).once.with('fs')
+	# check if fs type is configured
+	expect(subject).to receive(:ensure_fs_type_configured).once.with(env)
         # check the magento mounts are configured
-        expect(subject).to receive(:ensure_magento_mounts_configured).with(env)
+        expect(subject).to receive(:ensure_magento_mounts_configured).once.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)
+        expect(subject).to receive(:validate_magento2_root).once.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)
+        expect(subject).to receive(:inform_if_gatling_not_installed).once.with(env)
       end
     end
   end

data/spec/unit/command/ensure_firewall_disabled_for_incompatible_fs_types_spec.rb

@@ -0,0 +1,81 @@
+# -*- 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_firewall_disabled_for_incompatible_fs_types(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_firewall_disabled_for_incompatible_fs_types" do
+    context "when current fs type is compatible with the firewall and the firewall state was already defined" do
+      let(:retrieved_settings) { { "fs" => { "type" => "virtualbox" }, "firewall" => { "state" => true } } }
+      it "leaves the firewall enabled" do
+        # pretend the settings are retrieved from disk and return a fs type that does not clash with the firewall
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we do not notify the user that the firewall will be disabled
+        expect(ui).to receive(:info).never.with(/Disabling the firewall.*/)
+	# check if the firewall is still enabled
+        expect(subject).to receive(:update_settings).once.with(retrieved_settings)
+      end
+    end
+
+    context "when current fs type is compatible with the firewall and the firewall state was not yet defined" do
+      let(:retrieved_settings) { { "fs" => { "type" => "virtualbox" }, "firewall" => { } } }
+      it "does not changes the settings" do
+        # pretend the settings are retrieved from disk and return a fs type that does not clash with the firewall
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we do not notify the user that the firewall will be disabled
+        expect(ui).to receive(:info).never.with(/Disabling the firewall.*/)
+	# check if the settings are not changed
+        expect(subject).to receive(:update_settings).once.with(retrieved_settings)
+      end
+    end
+
+    context "when current fs type is not compatible with the firewall and the firewall state was already defined" do
+      let(:retrieved_settings) { { "fs" => { "type" => "nfs_guest" }, "firewall" => { "state" => true } } }
+      let(:expected_settings) { { "fs" => { "type" => "nfs_guest" }, "firewall" => { "state" => false } } }
+      it "changes the existing firewall state to disabled" do
+        # pretend the settings are retrieved from disk and return an incompatible fs type
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we notify the user that the firewall will be disabled
+        expect(ui).to receive(:info).once.with(/Disabling the firewall.*/)
+	# check if the firewall is disabled
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+      end
+    end
+
+    context "when current fs type is not compatible with the firewall and the firewall state was not defined" do
+      let(:retrieved_settings) { { "fs" => { "type" => "nfs_guest" }, "firewall" => { }  } }
+      let(:expected_settings) { { "fs" => { "type" => "nfs_guest" }, "firewall" => { "state" => false }  } }
+      it "creates a new firewall state disabled" do
+        # pretend the settings are retrieved from disk and return an incompatible fs type
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if we notify the user that the firewall will be disabled
+        expect(ui).to receive(:info).once.with(/Disabling the firewall.*/)
+	# check if the firewall is disabled
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+      end
+    end
+  end
+end

data/spec/unit/command/ensure_fs_type_configured_spec.rb

@@ -0,0 +1,47 @@
+# -*- 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.ensure_fs_type_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_fs_type_configured" do
+    context "fs type is configured" do
+      let(:retrieved_settings) { { "fs" => { "type" => "virtualbox"} } }
+      it "configures the fs type" do
+	# pretend we retrieve the settings and they specify no fs type
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if the fs type is not gotten because we already have it specified in the settings
+	expect(subject).to receive(:get_fs_type).never
+	# check if the settings are unchanged
+        expect(subject).to receive(:update_settings).once.with(retrieved_settings)
+      end
+    end
+
+    context "fs type is not configured" do
+      let(:retrieved_settings) { { "fs" => { } } }
+      let(:expected_settings) { { "fs" => { "type" => "rsync" }} }
+      it "configures the fs type" do
+	# pretend we retrieve the settings and they specify no fs type
+        expect(subject).to receive(:retrieve_settings).once.with(no_args).and_return(retrieved_settings)
+	# check if the fs type is gotten and pretend it returns rsync
+	expect(subject).to receive(:get_fs_type).once.with(env).and_return('rsync')
+	# check if the settings that are written back to disk contain the new fs type
+        expect(subject).to receive(:update_settings).once.with(expected_settings)
+      end
+    end
+  end
+end

data/spec/unit/command/ensure_settings_are_configured_spec.rb

@@ -41,6 +41,8 @@ describe VagrantHypconfigmgmt::Command do
         expect(subject).to receive(:configure_varnish).with(env)
 	# check the synced folder settings are configured
         expect(subject).to receive(:configure_synced_folders).with(env)
+	# check the firewall settings are configured
+        expect(subject).to receive(:configure_firewall).with(env)
 	# check the vagrant settings are configured
         expect(subject).to receive(:configure_vagrant).with(env)
 	# check true is returned when settings are updated
@@ -60,6 +62,8 @@ describe VagrantHypconfigmgmt::Command do
         expect(subject).to receive(:configure_varnish).with(env)
 	# check the synced folder settings are configured
         expect(subject).to receive(:configure_synced_folders).with(env)
+	# check the firewall settings are configured
+        expect(subject).to receive(:configure_firewall).with(env)
 	# check the vagrant settings are configured
         expect(subject).to receive(:configure_vagrant).with(env)
 	# check false is returned when settings are not updated

data/spec/unit/command/get_firewall_state_spec.rb

@@ -0,0 +1,56 @@
+# -*- 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 } }
+
+  # pretend env contains the Vagrant ui element
+  let(:ui) do
+    double('ui').tap do |ui|
+      allow(ui).to receive(:info) { 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 "#get_firewall_state" do
+
+    context "when the state is enabled" do
+      it "it notifies the user that it will be enabled and returns the value" do
+	# check if the setting is prompted for and pretend it returns a "firewall enabled" answer
+        expect(subject).to receive(:get_setting).with(
+	  env, AVAILABLE_FIREWALL_STATES, DEFAULT_FIREWALL_STATE,
+	  "Do you want to enable the production-like firewall? Enter true or false [default false]: "
+	).and_return("true")
+        # check if the user is notified that the firewall will be enabled
+        expect(ui).to receive(:info).once.with(/.*enabled.*/)
+	# check if the function returns true if the firewall should be enabled
+        expect( subject.get_firewall_state(env) ).to eq(true)
+      end
+    end
+
+
+    context "when the state is disabled" do
+      it "it notifies the user that it will be disabled and returns the value" do
+	# check if the setting is prompted for and pretend it returns a "firewall disabled" answer
+        expect(subject).to receive(:get_setting).with(
+	  env, AVAILABLE_FIREWALL_STATES, DEFAULT_FIREWALL_STATE,
+	  "Do you want to enable the production-like firewall? Enter true or false [default false]: "
+	).and_return("false")
+        # check if the user is notified that the firewall will be disabled
+        expect(ui).to receive(:info).once.with(/.*disabled.*/)
+	# check if the function returns false if the firewall should be disabled
+        expect( subject.get_firewall_state(env) ).to eq(false)
+      end
+    end
+  end
+end
+

data/spec/unit/command/get_fs_type_spec.rb

@@ -0,0 +1,97 @@
+# -*- 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 } }
+
+  # pretend env contains the Vagrant ui element
+  let(:ui) do
+    double('ui').tap do |ui|
+      allow(ui).to receive(:info) { 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 "#fs_type" do
+
+    context "when the user inputs an unknown fs type" do
+      it "returns fs type unknown" do
+	# check if the setting is prompted for and pretend it returns an "rsync" answer
+        expect(subject).to receive(:get_setting).with(
+	  env, AVAILABLE_FS_TYPES, DEFAULT_FS_TYPE,
+	  "What filesystem type do you want to use? Options: nfs_guest, nfs, rsync, virtualbox [default #{DEFAULT_FS_TYPE}]: "
+	).and_return("unknown_fs_type")
+        # check a message is printed about the fs type
+        expect(ui).to receive(:info).once.with(/.*Unknown.*/)
+	# check if the function returns the unknown fs type
+        expect( subject.get_fs_type(env) ).to eq("unknown_fs_type")
+      end
+    end
+
+    context "when the user inputs fs type rsync" do
+      it "returns fs type rsync" do
+	# check if the setting is prompted for and pretend it returns an "rsync" answer
+        expect(subject).to receive(:get_setting).with(
+	  env, AVAILABLE_FS_TYPES, DEFAULT_FS_TYPE,
+	  "What filesystem type do you want to use? Options: nfs_guest, nfs, rsync, virtualbox [default #{DEFAULT_FS_TYPE}]: "
+	).and_return("rsync")
+        # check a message is printed about the fs type
+        expect(ui).to receive(:info).once.with(/.*rsync.*filesync.*/)
+	# check if the function returns "rsync" 
+        expect( subject.get_fs_type(env) ).to eq("rsync")
+      end
+    end
+
+    context "when the user inputs fs type virtualbox" do
+      it "returns fs type virtualbox" do
+	# check if the setting is prompted for and pretend it returns a "virtualbox" answer
+        expect(subject).to receive(:get_setting).with(
+	  env, AVAILABLE_FS_TYPES, DEFAULT_FS_TYPE,
+	  "What filesystem type do you want to use? Options: nfs_guest, nfs, rsync, virtualbox [default #{DEFAULT_FS_TYPE}]: "
+	).and_return("virtualbox")
+        # check a message is printed about the fs type
+        expect(ui).to receive(:info).once.with(/.*is the default.*/)
+	# check if the function returns "virtualbox" 
+        expect( subject.get_fs_type(env) ).to eq("virtualbox")
+      end
+    end
+
+    context "when the user inputs fs type nfs_guest" do
+      it "returns fs type nfs_guest" do
+	# check if the setting is prompted for and pretend it returns an "nfs_guest" answer
+        expect(subject).to receive(:get_setting).with(
+	  env, AVAILABLE_FS_TYPES, DEFAULT_FS_TYPE,
+	  "What filesystem type do you want to use? Options: nfs_guest, nfs, rsync, virtualbox [default #{DEFAULT_FS_TYPE}]: "
+	).and_return("nfs_guest")
+        # check a message is printed about the fs type
+        expect(ui).to receive(:info).once.with(/.*host will mount NFS.*/)
+	# check if the function returns "nfs_guest" 
+        expect( subject.get_fs_type(env) ).to eq("nfs_guest")
+      end
+    end
+
+    context "when the user inputs fs type nfs" do
+      it "returns fs type nfs" do
+	# check if the setting is prompted for and pretend it returns an "nfs" answer
+        expect(subject).to receive(:get_setting).with(
+	  env, AVAILABLE_FS_TYPES, DEFAULT_FS_TYPE,
+	  "What filesystem type do you want to use? Options: nfs_guest, nfs, rsync, virtualbox [default #{DEFAULT_FS_TYPE}]: "
+	).and_return("nfs")
+        # check a message is printed about the fs type
+        expect(ui).to receive(:info).once.with(/.*guest will mount NFS.*/)
+	# check if the function returns "nfs" 
+        expect( subject.get_fs_type(env) ).to eq("nfs")
+      end
+    end
+  end
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-hypconfigmgmt
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Rick van de Loo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-27 00:00:00.000000000 Z
+date: 2016-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,20 +99,25 @@ files:
 - lib/vagrant-hypconfigmgmt/command.rb
 - lib/vagrant-hypconfigmgmt/config.rb
 - lib/vagrant-hypconfigmgmt/version.rb
-- pkg/vagrant-hypconfigmgmt-0.0.2.gem
+- pkg/vagrant-hypconfigmgmt-0.0.3.gem
 - spec/spec_helper.rb
 - spec/unit/command/call_spec.rb
+- spec/unit/command/configure_firewall_spec.rb
 - spec/unit/command/configure_magento_spec.rb
 - spec/unit/command/configure_php_spec.rb
 - spec/unit/command/configure_synced_folders_spec.rb
 - spec/unit/command/configure_vagrant_spec.rb
 - spec/unit/command/configure_varnish_spec.rb
 - spec/unit/command/ensure_attribute_configured_spec.rb
+- spec/unit/command/ensure_firewall_disabled_for_incompatible_fs_types_spec.rb
+- spec/unit/command/ensure_fs_type_configured_spec.rb
 - spec/unit/command/ensure_magento_mounts_configured_spec.rb
 - spec/unit/command/ensure_required_plugins_are_installed_spec.rb
 - spec/unit/command/ensure_setting_exists_spec.rb
 - spec/unit/command/ensure_settings_are_configured_spec.rb
 - spec/unit/command/ensure_vagrant_box_type_configured_spec.rb
+- spec/unit/command/get_firewall_state_spec.rb
+- spec/unit/command/get_fs_type_spec.rb
 - spec/unit/command/get_magento_version_spec.rb
 - spec/unit/command/get_options_string_spec.rb
 - spec/unit/command/get_php_version_spec.rb