vmesh 0.1.3

data/lib/vmesh/commands/revert.rb

@@ -0,0 +1,16 @@
+
+desc 'revert vm to previous snapshot'
+arg_name 'vm_name'
+
+command :revert do |c|
+  c.action do |global_options,options,args|
+    ARGV.size >= 1 or abort 'must specify VM'
+    vm_target = ARGV.shift
+    @logger.debug "Revert invoked for #{vm_target}\n\t#{global_options[:host]}\n\t#{options}\n\t#{args}."
+
+    vm_manager = Vmesh::VSphere.new global_options
+    vm = vm_manager.get_machine(vm_target, global_options[:datacenter])
+    Vmesh::logger.debug "Got vm #{vm.name}"
+    vm.revert 
+  end
+end

data/lib/vmesh/create.rb

@@ -0,0 +1,11 @@
+module Vmesh
+  def create(vim, datacenter, template_name, new_machine_name, ip_address)
+    # vm get
+    template = Vmesh::Machine::get vim, datacenter, template_name
+    # get spec, I think this is right?
+    spec = Vmesh::CustomSpec::get vim.serviceContent.customizationSpecManager
+    spec.destination_ip_address ip_address
+    # vm clone 
+    vm.clone new_machine_name, spec
+  end
+end

data/lib/vmesh/custom_spec.rb

@@ -0,0 +1,25 @@
+require 'rbvmomi'
+
+module Vmesh
+  class CustomSpec
+    attr_accessor :ip_address, :spec
+    def initialize(spec)
+      @spec = spec
+    end
+
+    def self.get(custom_spec_manager, name)
+      Vmesh::logger.debug "Looking for spec #{name}"
+      spec = custom_spec_manager.GetCustomizationSpec(:name => name).spec or raise "unable to find the custom spec #{name}."
+      CustomSpec.new(spec)
+    end
+
+    def destination_ip_address=(ip)
+      Vmesh::logger.debug "Setting spec ip address to #{ip}"
+      @spec.nicSettingMap.first.adapter.ip = RbVmomi::VIM::CustomizationFixedIp("ipAddress" => ip)
+    end
+
+    def destination_ip_address
+      @spec.nicSettingMap.first.adapter.ip
+    end
+  end
+end

data/lib/vmesh/datacenter.rb

@@ -0,0 +1,42 @@
+module Vmesh
+  class Datacenter
+    attr_accessor :dc
+    def initialize(datacenter) 
+      @dc = datacenter
+    end
+
+    def self.get(vim, datacenter_name)
+      dc = vim.serviceInstance.find_datacenter(datacenter_name) or abort "datacenter #{datacenter_name} not found"
+      Datacenter.new dc
+    end
+
+    # non wrapped object, gasp!
+    def self.find_pool(vim, name, dcname = nil)
+      Vmesh::logger.debug "Looking for datacenter pool #{name} in datacenter named #{dcname}."
+      dc = vim.serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
+      dc = Datacenter.get(vim, nil).dc
+      baseEntity = dc.hostFolder
+      entityArray = name.split('/')
+      entityArray.each do |entityArrItem|
+        if entityArrItem != ''
+          if baseEntity.is_a? RbVmomi::VIM::Folder
+            baseEntity = baseEntity.childEntity.find { |f| f.name == entityArrItem } or abort "no such pool #{name} while looking for #{entityArrItem}"
+          elsif baseEntity.is_a? RbVmomi::VIM::ClusterComputeResource
+            baseEntity = baseEntity.resourcePool.resourcePool.find { |f| f.name == entityArrItem } or abort "no such pool #{name} while looking for #{entityArrItem}"
+          elsif baseEntity.is_a? RbVmomi::VIM::ResourcePool
+            baseEntity = baseEntity.resourcePool.find { |f| f.name == entityArrItem } or abort "no such pool #{name} while looking for #{entityArrItem}"
+          else
+            abort "Unexpected Object type encountered #{baseEntity.type} while finding resourcePool"
+          end
+        end
+      end
+
+      baseEntity = baseEntity.resourcePool if not baseEntity.is_a?(RbVmomi::VIM::ResourcePool) and baseEntity.respond_to?(:resourcePool)
+      baseEntity
+    end
+
+    def name
+      @dc.name
+    end
+  end
+end

data/lib/vmesh/datastore.rb

@@ -0,0 +1,47 @@
+require 'rbvmomi'
+
+module Vmesh
+  class Datastore
+    attr_accessor :ds
+    def initialize(ds)
+      @ds = ds
+    end
+
+    def self.get(vim, name, datacenter)
+      Vmesh::logger.debug "Getting datastore named #{name} at datacenter #{datacenter.name}." 
+      stores = self.get_all(vim, datacenter).select{ |ds| ds.name == name }
+      if stores.nil? or stores.empty?
+        Vmesh::logger.info "No exact match found, searching for partial match"
+        stores = self.get_all(vim, datacenter).select{ |ds| ds.name.include? name }
+        Vmesh::logger.debug "Found #{stores.count} datastores."
+        Vmesh::logger.debug "#{stores.map{|ds| "Name #{ds.name}, free space #{ds.free_space}"}}"
+      end
+      stores.sort_by{ |ds| ds.free_space }.reverse.first
+    end
+
+    def self.get_all(vim, datacenter)
+      Vmesh::logger.debug "get_all datastores at #{datacenter.name}."
+      vim.serviceContent.viewManager.CreateContainerView({
+        :container  => datacenter.dc.datastoreFolder,
+        :type       => ["Datastore"],
+        :recursive  => true
+      }).view.map{ |ds| Datastore.new(ds) } #.select{|ds| ds.name == name}.first
+    end
+
+    def name
+      @ds.name
+    end
+
+    def free_space
+      @ds.summary.freeSpace
+    end
+
+    def capacity
+      @ds.summary.capacity
+    end
+
+    def to_s
+      "name: #{name}, free_space: #{free_space}, capacity: #{capacity}"
+    end
+  end
+end

data/lib/vmesh/list.rb

@@ -0,0 +1,4 @@
+module Vmesh
+  def list
+  end
+end

data/lib/vmesh/logger.rb

@@ -0,0 +1,14 @@
+module Vmesh
+  class <<self
+    attr_accessor :logger
+  end
+=begin
+  def self.logger
+    @logger
+  end
+  def self.logger=(logger)
+    @logger = logger
+  end
+=end
+end
+

data/lib/vmesh/machine.rb

@@ -0,0 +1,67 @@
+require 'rbvmomi'
+require 'logger'
+
+module Vmesh
+  class Machine
+    attr_accessor :name, :vm
+    @@states = {'on' => 'PowerOnVM_Task', 'off' => 'PowerOffVM_Task', 'reset' => 'ResetVM_Task', 'suspend' => 'SuspendVM_Task', 'destroy' => 'Destroy_Task' }
+
+    def initialize(vm)
+      Vmesh::logger.debug "New machine wrapper object with #{vm}"
+      @vm = vm
+    end
+
+    def self.get(vs_manager, datacenter_name, name)
+      Vmesh::logger.debug "looking for vm #{name} at dc #{datacenter_name}."
+      vm = vs_manager.vm_root_folder.traverse(name)
+      vm or raise "unable to find machine #{name} at #{datacenter_name}"
+      Machine.new vm 
+    end
+
+    def self.valid_states
+      @@states.keys
+    end
+
+    def power(desired_state)
+      p "Found" if @@states.has_key? desired_state
+      p "NOT Found" unless @@states.has_key? desired_state
+      raise ArgumentError, "Invalid desired power state" unless @@states.has_key? desired_state
+      @vm.send(@@states[desired_state])
+    end
+
+    def revert
+      @vm.RevertToCurrentSnapshot_Task.wait_for_completion
+    end
+
+    def command
+      raise NotImplementedError
+    end
+
+    def describe
+      raise NotImplementedError
+    end
+
+    def template?
+      raise NotImplementedError
+    end
+
+    def ipAddress
+      @vm.guest.ipAddress
+    end
+
+    def clone_to (vm_name, vm_folder = @vm.parent, datastore = nil, custom_spec = nil, pool = nil, config = {})
+      Vmesh::logger.info "Cloning #{@name} to a new vm named #{vm_name} in folder #{vm_folder}."
+      ds = datastore.ds unless datastore.nil?
+      relocateSpec = RbVmomi::VIM.VirtualMachineRelocateSpec(:datastore    => ds,
+                                                             :diskMoveType => :moveChildMostDiskBacking,
+                                                             :pool         => pool)
+      clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(:location => relocateSpec,
+                                                        :powerOn  => false,
+                                                        :template => false)
+      clone_spec.customization = custom_spec.spec if custom_spec
+      Vmesh::logger.debug "Custom spec #{custom_spec} supplied, config #{config.inspect}."
+
+      Machine.new(@vm.CloneVM_Task(:folder => vm_folder, :name => vm_name, :spec => clone_spec, :numCPUs => config[:numCPUs], :memoryMB => config[:memoryMB]).wait_for_completion)
+    end
+  end
+end

data/lib/vmesh/server_defaults.rb

@@ -0,0 +1,25 @@
+module Vmesh
+  @template = {
+    :windows_dmz => {
+      :name => 'Templates/W2012_DC',
+      :spec => 'Windows2012R2_DC_DMZ'
+    },
+    :windows => {
+      :name => 'Templates/W2012R2',
+      :spec => 'Win2012R2_DC_Frontend'
+      #:name => 'Templates/W2012R2_DC',
+    },
+    :linux => {
+      :name => 'Templates/CENTOS_6',
+      :spec => 'Linux No Prompt'
+    },
+    :suse => {
+      :name => 'Templates/SLES11-2-WHICS',
+      :spec => 'Linux No Prompt'
+    }
+  }
+
+  def self.template
+    @template
+  end
+end

data/lib/vmesh/version.rb

@@ -0,0 +1,3 @@
+module Vmesh
+  VERSION = '0.1.3'
+end

data/lib/vmesh/vsphere.rb

@@ -0,0 +1,88 @@
+require 'rbvmomi'
+require 'logger'
+
+# VM Manager Class to hand all things VSphere
+module Vmesh
+  class VSphere
+    attr_accessor :vim, :options
+    def initialize(connection_options)
+      Vmesh::logger.debug "Opening connection to #{connection_options['host']}"
+      @vim = RbVmomi::VIM.connect connection_options
+      @options = connection_options
+    end
+
+    # Can we search through the datacenters for a machine?
+    # Should we get the machine from the datacenters?
+    def get_machine(machine_name, datacenter)
+      Machine::get(self, datacenter, machine_name)
+    end
+
+    def clone_machine(vm_type, vm_target, default_vm_folder, machine_options)
+      Vmesh::template.has_key? vm_type.to_sym or raise "unknown machine type #{vm_type}, known types are #{Vmesh::template.keys.to_s}"
+      config = {}
+      template = Vmesh::template[vm_type.to_sym]
+      vm_dest = VSphere.parse_vm_target vm_target, default_vm_folder
+      vm_template = get_machine(template[:name], @options[:datacenter])
+      # Refactor & pass in options with the get or alternatively add a get and set method
+      spec = get_custom_spec(template[:spec])
+      spec.destination_ip_address = machine_options[:ip_address] if machine_options[:ip_address]
+      config[:numCPUs] = machine_options[:numCPUs] if machine_options[:numCPUs].to_s != ''
+      config[:memoryMB] = machine_options[:memoryMB] if machine_options[:memoryMB].to_s != ''
+      pool = get_resource_pool(@options[:resource_pool], @options[:datacenter])
+      datacenter = get_datacenter(@options[:datacenter])
+      datastore = get_datastore(machine_options[:datastore], datacenter)
+      raise "No datastore found matching #{machine_options[:datastore]}. Exiting." if datastore.nil?
+      Vmesh::logger.debug "Got datastore named #{datastore.name} with free space #{datastore.free_space}."
+      Vmesh::logger.debug "Creating vm in folder #{vm_dest[:folder]} with name #{vm_dest[:name]}."
+      folder = get_folder(vm_dest[:folder], @options[:datacenter])
+      Vmesh::logger.debug "Using folder #{folder.to_s}."
+      vm_template.clone_to(vm_dest[:name], folder, datastore, spec, pool, config)
+    end
+
+    def get_custom_spec(name)
+      spec_mgr = @vim.serviceContent.customizationSpecManager
+      CustomSpec::get(spec_mgr, name)
+    end
+
+    def get_resource_pool(name, datacenter_name)
+      # KRUT this should be a ResourcePool wrapper object instead?
+      Vmesh::logger.debug "Chasing resource pool #{name}"
+      Datacenter::find_pool(@vim, name, datacenter_name)
+    end
+
+    def get_datastore(name, datacenter)
+      Vmesh::logger.debug "Getting datastore #{name}"
+      Datastore::get(@vim, name, datacenter)
+    end
+
+    def get_datacenter(name)
+      Vmesh::Datacenter::get(@vim, name)
+    end
+
+    def root_folder
+      @vim.serviceInstance.content.rootFolder
+    end
+
+    def vm_root_folder
+      @vim.serviceInstance.content.rootFolder.traverse(@options[:datacenter]).vmFolder
+    end
+
+    def get_folder(path, datacenter_name = @options[:datacenter])
+      Vmesh::logger.debug "Looking for folder #{path}."
+      path.to_s == '/' ? vm_root_folder : vm_root_folder.traverse(path)
+    end
+
+    private
+      def self.parse_vm_target(vm_target, default_vm_path = '/')
+        vm_details = vm_target.match(/(.+)\/(.+)/)
+        vm = Hash.new
+        vm[:folder] = default_vm_path
+        vm[:name]   = vm_target
+        if vm_details
+          vm[:folder] = vm_details[1]
+          vm[:name]   = vm_details[2]
+        end
+        vm
+      end
+  end
+end

data/lib/vmesh.rb

@@ -0,0 +1,20 @@
+require 'vmesh/version.rb'
+
+# Add requires for other files you add to your project here, so
+# you just need to require this one file in your bin file
+
+require 'vmesh/server_defaults.rb'
+require 'vmesh/machine.rb'
+require 'vmesh/logger.rb'
+require 'vmesh/create.rb'
+require 'vmesh/list.rb'
+require 'vmesh/custom_spec.rb'
+require 'vmesh/datacenter.rb'
+require 'vmesh/vsphere.rb'
+require 'vmesh/datastore.rb'
+
+module Vmesh
+  def self.logger
+    @logger ||= Logger.new STDOUT
+  end
+end

data/test/create_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+require 'vmesh/commands/create_helpers'
+
+class CreateTest < Test::Unit::TestCase
+#class CreateTest < Test::Test
+
+  def setup
+    Vmesh::logger = Logger.new(RUBY_PLATFORM =~ /mswin|mingw/ ? 'NUL:' : '/dev/null', 7)
+  end
+
+  def teardown
+  end
+
+  def test_parse_vm_target_with_folder
+    #vm_details = Vmesh::parse_vm_target("dummy_folder/dummy_vm_name")
+    #assert vm_details.is_hash?
+    assert true
+  end
+end
+
+=begin
+        def get_raw_vmfolder(path, datacenter_name)
+          # The required path syntax - 'topfolder/subfolder
+
+          # Clean up path to be relative since we're providing datacenter name
+          dc = find_raw_datacenter(datacenter_name)
+          dc_root_folder = dc.vmFolder
+          # Filter the root path for this datacenter not to be used."
+          dc_root_folder_path=dc_root_folder.path.map { | id, name | name }.join("/")
+          paths = path.sub(/^\/?#{Regexp.quote(dc_root_folder_path)}\/?/, '').split('/')
+
+          return dc_root_folder if paths.empty?
+          # Walk the tree resetting the folder pointer as we go
+          paths.inject(dc_root_folder) do |last_returned_folder, sub_folder|
+            # JJM VIM::Folder#find appears to be quite efficient as it uses the
+            # searchIndex It certainly appears to be faster than
+            # VIM::Folder#inventory since that returns _all_ managed objects of
+            # a certain type _and_ their properties.
+            sub = last_returned_folder.find(sub_folder, RbVmomi::VIM::Folder)
+            raise ArgumentError, "Could not descend into #{sub_folder}. Please check your path. #{path}" unless sub
+            sub
+          end
+        end
+=end
+

data/test/datastore_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+include RbVmomi
+include Vmesh
+
+class DatastoreTest < Test::Unit::TestCase
+
+  def setup
+    Vmesh::logger = Logger.new(RUBY_PLATFORM =~ /mswin|mingw/ ? 'NUL:' : '/dev/null', 7)
+  end
+
+  def teardown
+  end
+
+  def test_gets_exact_match_not_partial
+    fake_ds1,matching_fake,fake_ds2 = mock,mock,mock
+    vim,dc = mock,mock
+    fake_ds1.stubs(:name => "GRAIN_STORE", :free_space => 100)
+    matching_fake = stub(:name => "GRAIN_STORE_1", :free_space => 200)
+    fake_ds2.stubs(:name => "BRAIN_STORE", :free_space => 200)
+    stores = [fake_ds1, matching_fake, fake_ds2]
+    dc.stubs(:name => 'fake_dc')
+    Vmesh::Datastore.stubs(:get_all => stores)
+
+    store = Vmesh::Datastore.get vim,'GRAIN_STORE_1',dc
+
+    assert_equal matching_fake,store
+  end
+
+  def test_gets_partial_with_most_space_when_no_exact_match
+    fake_ds1,matching_fake,fake_ds2 = mock,mock,mock
+    vim,dc = mock,mock
+    fake_ds1.stubs(:name => "GRAIN_STORE", :free_space => 100)
+    matching_fake = stub(:name => "GRAIN_STORE_1", :free_space => 200)
+    fake_ds2.stubs(:name => "BRAIN_STORE", :free_space => 20)
+    stores = [fake_ds1, matching_fake, fake_ds2]
+    dc.stubs(:name => 'fake_dc')
+    Vmesh::Datastore.stubs(:get_all => stores)
+
+    store = Vmesh::Datastore.get vim,'RAIN_STORE',dc
+    
+    assert_equal matching_fake,store
+  end
+end

data/test/machine_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+include RbVmomi
+include Vmesh
+
+class MachineTest < Test::Unit::TestCase
+
+  def setup
+    Vmesh::logger = Logger.new(RUBY_PLATFORM =~ /mswin|mingw/ ? 'NUL:' : '/dev/null', 7)
+  end
+
+  def teardown
+  end
+
+=begin
+  def test_get_machine_uses_vim_connection
+    connection_options = Hash.new
+    VIM.stubs(:connect).returns("a string")
+    vsphere_vm_manager = VSphere.new(connection_options)
+    #Machine.expects(:get).returns("fake vm")
+    mock_vm = Object.new
+    Machine.stubs( :get ).returns(mock_vm)
+           #returns( stub(:cool? => true) ) # returns an object with just a .cool? method which in turn returns true
+
+    vm = vsphere_vm_manager.get_machine("fake_machine","fake datacenter")
+    
+    assert vm == mock_vm
+  end
+=end
+
+  def test_clone_machine_uses_custom_spec
+    vm_template, fake_task = mock, mock
+    fake_task.expects(:wait_for_completion)
+    vm_template.expects(:CloneVM_Task).returns(fake_task)
+    template = Machine.new(vm_template)
+    mock_custom_spec = mock
+    mock_custom_spec.stubs(:spec)
+    VIM.stubs(:VirtualMachineRelocateSpec)
+    mock_clone_spec = mock
+    mock_clone_spec.expects(:customization=)
+    VIM.stubs(:VirtualMachineCloneSpec).returns(mock_clone_spec)
+
+    template.clone_to 'frank', '/', nil, mock_custom_spec
+  end
+
+  def test_power_on_invokes_PowerOnVMTask
+    fake_vs_vm = mock
+    vm = Machine.new(fake_vs_vm)
+    fake_vs_vm.expects(:PowerOnVM_Task)
+
+    vm.power 'on'
+  end
+
+  def test_power_off_invokes_PowerOffVMTask
+    fake_vs_vm = mock
+    vm = Machine.new(fake_vs_vm)
+    fake_vs_vm.expects(:PowerOffVM_Task)
+
+    vm.power 'off'
+  end
+
+  def test_power_reset_invokes_PowerOnVMTask
+    fake_vs_vm = mock
+    vm = Machine.new(fake_vs_vm)
+    fake_vs_vm.expects(:ResetVM_Task)
+
+    vm.power 'reset'
+  end
+
+  def test_power_suspend_invokes_PowerOnVMTask
+    fake_vs_vm = mock
+    vm = Machine.new(fake_vs_vm)
+    fake_vs_vm.expects(:SuspendVM_Task)
+
+    vm.power 'suspend'
+  end
+
+  def test_power_destroy_invokes_PowerOnVMTask
+    fake_vs_vm = mock
+    vm = Machine.new(fake_vs_vm)
+    fake_vs_vm.expects(:Destroy_Task)
+
+    vm.power 'destroy'
+  end
+
+  def test_power_unknown_raises
+    fake_vs_vm = mock
+    vm = Machine.new(fake_vs_vm)
+    #fake_vs_vm.expects(:PowerOnVM_Task)
+
+    assert_raise(ArgumentError) { vm.power "to the people" }
+  end
+end

data/test/power_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+require 'mocha/test_unit'
+
+include RbVmomi
+include Vmesh
+
+class VSphereTest < Test::Unit::TestCase
+
+  def setup
+    @mock_vim = Object.new
+    #@mock_vim = mock RbVmomi::VIM
+    VIM.stubs(:connect).returns(@mock_vim)
+    @mock_connection_options = Hash.new
+    Vmesh::logger = Logger.new(RUBY_PLATFORM =~ /mswin|mingw/ ? 'NUL:' : '/dev/null', 7)
+  end
+
+  def teardown
+  end
+
+  def test_root_folder_gets_from_vim
+    vsphere_vm_manager = VSphere.new(@mock_connection_options)
+    mock_root_folder = Object.new
+    mock_content = Object.new
+    mock_content.expects(:rootFolder).returns(mock_root_folder)
+    mock_service_instance = Object.new
+    mock_service_instance.expects(:content).returns(mock_content)
+    @mock_vim.expects(:serviceInstance).returns(mock_service_instance) #Object.new.expects(:content).expects(:rootFolder).returns('a folder'))
+
+    root_folder = vsphere_vm_manager.root_folder 
+
+    assert root_folder == mock_root_folder
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+#require 'minitest/autorun'
+require 'test/unit'
+# At bottom of test_helper.rb
+#require "mocha/setup"
+
+
+=begin
+# Add test libraries you want to use here, e.g. mocha
+require 'mocha/mini_test'
+=end
+require_relative '../lib/vmesh.rb'
+require 'mocha/setup'
+require 'mocha/test_unit'
+
+
+class Test::Unit::TestCase
+#class Test::Test
+
+  # Add global extensions to the test case class here
+  
+end
+

data/test/vsphere_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+require 'mocha/test_unit'
+
+include RbVmomi
+include Vmesh
+
+class VSphereTest < Test::Unit::TestCase
+
+  def setup
+    @mock_vim = Object.new
+    VIM.stubs(:connect).returns(@mock_vim)
+    @mock_connection_options = Hash.new
+    Vmesh::logger = Logger.new(RUBY_PLATFORM =~ /mswin|mingw/ ? 'NUL:' : '/dev/null', 7)
+  end
+
+  def teardown
+  end
+
+  def test_get_machine_uses_vim_connection
+    vsphere_vm_manager = VSphere.new(@mock_connection_options)
+    #Machine.expects(:get).returns('fake vm')
+    mock_vm = Object.new
+    Machine.stubs( :get ).returns(mock_vm)
+           #returns( stub(:cool? => true) ) # returns an object with just a .cool? method which in turn returns true
+
+    vm = vsphere_vm_manager.get_machine('fake_machine','fake datacenter')
+    
+    assert vm == mock_vm
+  end
+
+  def test_root_folder_gets_from_vim
+    vsphere_vm_manager = VSphere.new(@mock_connection_options)
+    mock_root_folder = Object.new
+    mock_content = Object.new
+    mock_content.expects(:rootFolder).returns(mock_root_folder)
+    mock_service_instance = Object.new
+    mock_service_instance.expects(:content).returns(mock_content)
+    @mock_vim.expects(:serviceInstance).returns(mock_service_instance) #Object.new.expects(:content).expects(:rootFolder).returns('a folder'))
+
+    root_folder = vsphere_vm_manager.root_folder 
+
+    assert root_folder == mock_root_folder
+  end
+end